diff --git a/data_analysis/notebooks/repo_level_context.ipynb b/data_analysis/notebooks/repo_level_context.ipynb new file mode 100644 index 0000000..795b202 --- /dev/null +++ b/data_analysis/notebooks/repo_level_context.ipynb @@ -0,0 +1,11558 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "81df851e-2450-46e9-b50b-72eea605e150", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from tqdm import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d071624d-77bd-428d-bdc7-28a227b53ac2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from transformers import PreTrainedTokenizerFast\n", + "from datasets import load_dataset\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "234e5933-77e9-498d-95de-83a460b9bccd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "34cdcb36-a357-48eb-befb-a5b8a8a3b948", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e9664330-80b9-49ca-a2b5-51853df82848", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset parquet (/transformers_cache/datasets/bigcode___parquet/bigcode--stackv2_repo_context_sample-e848b64a9740f86d/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9d1f1d72630e4ad4927dd2436de20863", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00{file['path']}\\n{file['content']}\"\n", + "\n", + "def process_repo(repo):\n", + " # Order files by path\n", + " ordered_files = sorted(repo['files'], key=lambda f: f['path'])\n", + " # print(f\"File order:\\n{[f['path'] for f in ordered_files]}\")\n", + " # Concatenate files\n", + " repo_content = ''.join([file_content(f) for f in ordered_files])\n", + " return repo_content" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "928bf828-e09c-41cd-84f7-0438e68f08a1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def tokenized_lengths(repo):\n", + " content = process_repo(repo)\n", + " tokenized = sc_tokenizer.encode(content)\n", + " sc_length = len(tokenized)\n", + " \n", + " tokenized = gpt4_tokenizer.encode(content)\n", + " gpt4_length = len(tokenized)\n", + " return {\n", + " \"sc_length\": sc_length,\n", + " \"gpt4_length\": gpt4_length\n", + " }\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "35be9360-cc85-4680-b915-c0b7f027325b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The OrderedVocab you are attempting to save contains a hole for index 100256, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100261, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100262, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100263, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100264, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100265, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100266, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100267, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100268, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100269, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100270, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100271, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100272, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100273, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100274, your vocabulary could be corrupted !\n", + "The OrderedVocab you are attempting to save contains a hole for index 100275, your vocabulary could be corrupted !\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Map (num_proc=4): 0%| | 0/1002 [00:008k 413\n" + ] + } + ], + "source": [ + "print(\">8k\", len([l for l in sc_lengths if l > 8192]))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a9c0ca0d-50a5-4af9-8546-f08cd46fa07a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<10M 999\n", + "<1M 973\n", + "<100k 827\n", + "<10k 616\n", + "<1k 262\n", + "<100 108\n", + "<10 0\n" + ] + } + ], + "source": [ + "#Num < 1e6\n", + "print(\"<10M\", len([l for l in sc_lengths if l < 1e7]))\n", + "print(\"<1M\", len([l for l in sc_lengths if l < 1e6]))\n", + "print(\"<100k\", len([l for l in sc_lengths if l < 1e5]))\n", + "print(\"<10k\", len([l for l in sc_lengths if l < 1e4]))\n", + "print(\"<1k\", len([l for l in sc_lengths if l < 1e3]))\n", + "print(\"<100\", len([l for l in sc_lengths if l < 1e2]))\n", + "print(\"<10\", len([l for l in sc_lengths if l < 1e1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2bbcad83-2489-428b-b84c-32111b462f6c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<10M 1001\n", + "<1M 974\n", + "<100k 840\n", + "<10k 634\n", + "<1k 281\n", + "<100 114\n", + "<10 5\n" + ] + } + ], + "source": [ + "#Num < 1e6\n", + "print(\"<10M\", len([l for l in gpt4_lengths if l < 1e7]))\n", + "print(\"<1M\", len([l for l in gpt4_lengths if l < 1e6]))\n", + "print(\"<100k\", len([l for l in gpt4_lengths if l < 1e5]))\n", + "print(\"<10k\", len([l for l in gpt4_lengths if l < 1e4]))\n", + "print(\"<1k\", len([l for l in gpt4_lengths if l < 1e3]))\n", + "print(\"<100\", len([l for l in gpt4_lengths if l < 1e2]))\n", + "print(\"<10\", len([l for l in gpt4_lengths if l < 1e1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "68b54a72-cbb5-4c4b-8174-3ecfc559266f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "352d5126634e4c2e9e153f771c521f8b", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(sc_lengths, bins=[2**k for k in range(25)])\n", + "plt.xscale(\"log\")\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "a9b576d7-825d-488d-840e-07d35067486a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d158cf8d0b740058036b47607c461ec", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(sc_lengths, bins=[2**k for k in range(25)], cumulative=True)\n", + "plt.xscale(\"log\")\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7223f64e-3674-4772-bd07-11947079e1d5", + "metadata": {}, + "source": [ + "# Filtering" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "184182ea-c743-443e-9e5e-3b8361bf581f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from pathlib import Path\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "8cae756f-355f-44ba-a180-54496ba2a6ca", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"/home/toolkit/code/bigcode-dataset/preprocessing\")" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "3a22820f-6bb6-4208-9743-d3257e878d06", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from filtering import load_filter_csv, language_format_from_dataset, LANG, filter_xml" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "90791359-9ef0-4c93-ba49-ad4953752f98", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from collections import Counter\n", + "not_csv_counter = Counter()" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "ab1fc12d-e3b4-4367-9b10-586857546dd1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def filter_large_and_small_files(example):\n", + " return 50 <= example['size'] and example['size'] <= 5000\n", + "\n", + "def basic_filters_per_extension(example, ext_to_filter):\n", + " \"\"\"Filter files based on line length and % alphanumeric characters.\n", + " The filtering parameters depend on the file extension, given by `ext_to_filter`\"\"\"\n", + " # For .txt , whitelist requirements.txt\n", + " if example[LANG] == \"text\" and example[\"ext\"]:\n", + " return example['path'].endswith(\"requirements.txt\")\n", + " # XML filter\n", + " if example[LANG] != \"xslt\" and not filter_xml(example):\n", + " return False\n", + " # Large and small files\n", + " if (example[LANG] == \"json\" or example[LANG] == \"yaml\") and not filter_large_and_small_files(example):\n", + " return False\n", + " \n", + " # Get the filter-params we want to use\n", + " # extension `None` is an empty string in the csv\n", + " try:\n", + " (include, line_max, line_mean, alphanum_frac, alphabetic_frac) = ext_to_filter[(language_format_from_dataset(\n", + " example[LANG]), example[\"ext\"] if example[\"ext\"] is not None else \"\"\n", + " )]\n", + " except KeyError as e:\n", + " # Some extensions are not in the csv. This happens for dockerfiles.\n", + " # Exclude these files\n", + " # logging.error(str(e) + f\":{example['ext']} not in ext_to_filter\")\n", + " not_csv_counter.update([(language_format_from_dataset(example[LANG]), example[\"ext\"])])\n", + " include = False\n", + " if not include:\n", + " return False\n", + " if line_max and example[\"max_line_length\"] > line_max:\n", + " return False\n", + " elif line_mean and example[\"avg_line_length\"] > line_mean:\n", + " return False\n", + " # Filter files with low percentage of alphanumeric chars\n", + " elif alphanum_frac and example[\"alphanum_fraction\"] < alphanum_frac:\n", + " return False\n", + " # Filter files with low percentage of alphabetic chars\n", + " elif alphabetic_frac and sum(map(str.isalpha, example['content'])) < alphabetic_frac * len(example['content']):\n", + " return False\n", + " return True" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "bdf2fcb2-0d08-4eab-b197-8f4fea1d91ff", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "per_extension_filter_csv = \"/home/toolkit/code/bigcode-dataset/preprocessing/visual_inspection.csv\"\n", + "ext_to_filter = load_filter_csv(per_extension_filter_csv)\n", + "# Add toml\n", + "ext_to_filter[(\"toml\", \"toml\")] = ext_to_filter[(\"python\", \"py\")]\n", + "\n", + "def filter_repo(repo):\n", + " for f in repo['files']:\n", + " # Get some stats\n", + " size = len(f[\"content\"])\n", + " line_lengths = [len(line) for line in f[\"content\"].splitlines()]\n", + " alpha_frac = np.mean([c.isalnum() for c in f[\"content\"]])\n", + " # Get the extension without the dot\n", + " f['ext'] = Path(f['path']).suffix[1:]\n", + " f['size'] = size\n", + " f[\"avg_line_length\"] = np.mean(line_lengths)\n", + " f[\"max_line_length\"] = max(line_lengths)\n", + " f[\"alphanum_fraction\"] = alpha_frac\n", + " \n", + " return {\n", + " \"files\": [\n", + " f for f in repo['files']\n", + " if basic_filters_per_extension(f, ext_to_filter=ext_to_filter)\n", + " ]\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "df07d080-72c7-46f0-baf5-00e8803e0bcb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Map (num_proc=4): 0%| | 0/1002 [00:00\n", + "
\n", + " Figure\n", + "
\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(filtered3[\"sc_length\"], bins=[2**k for k in range(25)])\n", + "plt.xscale(\"log\")\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "26ace73c-7fce-4091-871f-48096d79a05b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "59dc73dd560b4a8db2d37acc48ff5b2c", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(sc_lengths, bins=[2**k for k in range(25)], alpha=0.5, label=\"raw\")\n", + "plt.hist(filtered[\"sc_length\"], bins=[2**k for k in range(25)], alpha=0.4, label=\"after filtering\")\n", + "plt.xscale(\"log\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "0fe27513-0000-46ae-83f5-ec3123d40646", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ebf02274641f465c9a1914ac129cca49", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(sc_lengths, bins=[2**k for k in range(25)], alpha=0.5, label=\"raw\")\n", + "plt.hist(filtered3[\"sc_length\"], bins=[2**k for k in range(25)], alpha=0.4, label=\"after filtering\")\n", + "plt.xscale(\"log\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "e248d315-baf7-448f-bdca-d58b9adedd7b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1002" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(filtered)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "e4c98fca-dc09-4c5c-b3e0-fa58f0cab7e9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "min(sc_lengths)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "5b7fbfb0-a597-4062-9c7f-8763066da0d2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "min(filtered[\"sc_length\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "55a46fc6-2fe3-468a-8df1-9c595869ac00", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">8k 245\n", + ">16k 173\n", + "<10M 1002\n", + "<1M 999\n", + "<100k 935\n", + "<10k 777\n", + "<1k 378\n", + "<100 207\n", + "<10 79\n" + ] + } + ], + "source": [ + "print(\">8k\", len([l for l in filtered3[\"sc_length\"] if l > 8192]))\n", + "print(\">16k\", len([l for l in filtered3[\"sc_length\"] if l > 16000]))\n", + "#Num < 1e6\n", + "print(\"<10M\", len([l for l in filtered3[\"sc_length\"] if l < 1e7]))\n", + "print(\"<1M\", len([l for l in filtered3[\"sc_length\"] if l < 1e6]))\n", + "print(\"<100k\", len([l for l in filtered3[\"sc_length\"] if l < 1e5]))\n", + "print(\"<10k\", len([l for l in filtered3[\"sc_length\"] if l < 1e4]))\n", + "print(\"<1k\", len([l for l in filtered3[\"sc_length\"] if l < 1e3]))\n", + "print(\"<100\", len([l for l in filtered3[\"sc_length\"] if l < 1e2]))\n", + "print(\"<10\", len([l for l in filtered3[\"sc_length\"] if l < 1e1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "9ab06154-f442-49a6-a019-ae8e61b44091", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e6c0bdc8e67446efa6454fd410e95773", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "plt.hist(sc_lengths, bins=[2**k for k in range(25)], cumulative=True, alpha=0.5, label=\"raw\")\n", + "plt.hist(filtered3[\"sc_length\"], bins=[2**k for k in range(25)], cumulative=True, alpha=0.4, label=\"after filtering\")\n", + "plt.xscale(\"log\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "998cafc7-6832-4b62-ab1a-feab42cccb3b", + "metadata": {}, + "source": [ + "### By number of tokens instead of repos" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "id": "42ba3e27-21e6-4b05-9781-dafff3f5d4f4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Cumulative distribution of the document-length on the token level.\n", + "repo_length_lims = [2**k for k in range(26)]\n", + "total_tokens = sum(filtered3[\"sc_length\"])\n", + "# Number of tokens in documents (repos) of length lower than the given limit.\n", + "y = [sum([l for l in filtered3[\"sc_length\"] if l < x]) for x in repo_length_lims]\n", + "y_normalized = [e / total_tokens for e in y]\n", + "\n", + "num_repos_below_limit = [len([l for l in filtered3[\"sc_length\"] if l < x]) for x in repo_length_lims]" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "id": "b6fce49d-3d1f-4f44-8aeb-d920431156e4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.04646120064680181" + ] + }, + "execution_count": 184, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum([l for l in filtered3[\"sc_length\"] if l < 8192]) / total_tokens" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "id": "1626aba9-2b86-4ed4-90c0-130529455a80", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "551a9f32866e40298692b8f37db057a6", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(repo_length_lims, y_normalized)\n", + "plt.grid()\n", + "plt.xscale(\"log\")\n", + "# plt.title(\"Cumulative distribution of sequence-lengths\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c62c0518-8a97-4a60-8742-756bf9320645", + "metadata": {}, + "outputs": [], + "source": [ + "[e for e in filtered3]" + ] + }, + { + "cell_type": "markdown", + "id": "834fd493-228a-4701-bf8c-f56a3c79d86a", + "metadata": {}, + "source": [ + "# Python repos" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "6bd880d8-0c19-4164-ada4-35666a4c6e42", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def repo_language(repo):\n", + " file_languages = [f[LANG] for f in repo['files']]\n", + " if len(file_languages) > 0:\n", + " return {\"repo_language\": Counter(file_languages).most_common(1)[0][0]}\n", + " else:\n", + " return {\"repo_language\": None}" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "a7972098-8171-4eba-be7c-81e54da66b04", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'repo_language': 'Rust'}" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "repo_language(filtered3[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "24761d20-931b-4ea9-8ba4-be4bb7fcb339", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Map (num_proc=4): 0%| | 0/1002 [00:00\n", + "
\n", + " Figure\n", + "
\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "# plt.hist(filtered3[\"sc_length\"], bins=[2**k for k in range(25)], alpha=0.5, label=\"after filtering\")\n", + "plt.hist(python_subset[\"sc_length\"], bins=[2**k for k in range(25)], alpha=0.5, label=\"after filtering - python\")\n", + "plt.xscale(\"log\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "7124f33c-f997-4ea5-aa0e-fcbf5a4612f6", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "58bb36c321734e03adebf27353672506", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "# plt.hist(filtered3[\"sc_length\"], bins=[2**k for k in range(25)], alpha=0.5, label=\"after filtering\")\n", + "plt.hist(python_subset[\"sc_length\"], bins=[2**k for k in range(25)], alpha=0.5, cumulative=True, label=\"after filtering - python\")\n", + "plt.xscale(\"log\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "72272bfd-4295-4f7e-8680-e28d72ab831f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'repo_name': 'rehack/swc',\n", + " 'repo_url': 'https://github.com/rehack/swc',\n", + " 'snapshot_id': 'a076ed7cc66678c23d5df2c722f504dd975a1b80',\n", + " 'revision_id': 'd19df1379cc24fd14089c815badbca2be533fa48',\n", + " 'branch_name': 'refs/heads/master',\n", + " 'visit_date': Timestamp('2023-08-11 03:05:08.228166'),\n", + " 'revision_date': Timestamp('2021-10-08 15:05:59'),\n", + " 'committer_date': Timestamp('2021-10-08 15:05:59'),\n", + " 'github_id': None,\n", + " 'star_events_count': 0,\n", + " 'fork_events_count': 0,\n", + " 'gha_license_id': None,\n", + " 'gha_fork': None,\n", + " 'gha_event_created_at': None,\n", + " 'gha_created_at': None,\n", + " 'gha_updated_at': None,\n", + " 'gha_pushed_at': None,\n", + " 'gha_size': None,\n", + " 'gha_stargazers_count': None,\n", + " 'gha_forks_count': None,\n", + " 'gha_open_issues_count': None,\n", + " 'gha_language': None,\n", + " 'gha_archived': None,\n", + " 'gha_disabled': None,\n", + " 'files': [{'alphanum_fraction': 0.5116555443824847,\n", + " 'avg_line_length': 22.029473684210526,\n", + " 'blob_id': 'f0af42828749d26140e01b3b7f9be8d8cf2a5988',\n", + " 'content': 'use rustc_hash::FxHashSet;\\nuse std::time::Instant;\\nuse swc_common::{\\n pass::{CompilerPass, Repeated},\\n util::take::Take,\\n Mark, Span, Spanned, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id, ModuleItemLike, StmtLike, Value};\\nuse swc_ecma_visit::{noop_visit_type, Fold, FoldWith, Node, Visit, VisitWith};\\n\\npub(crate) mod base54;\\npub(crate) mod sort;\\npub(crate) mod unit;\\n\\n///\\npub(crate) fn make_number(span: Span, value: f64) -> Expr {\\n if cfg!(feature = \"debug\") {\\n tracing::debug!(\"Creating a numeric literal\");\\n }\\n Expr::Lit(Lit::Num(Number { span, value }))\\n}\\n\\npub trait MoudleItemExt:\\n StmtLike + ModuleItemLike + From + Spanned + std::fmt::Debug\\n{\\n fn as_module_decl(&self) -> Result<&ModuleDecl, &Stmt>;\\n\\n fn from_module_item(item: ModuleItem) -> Self;\\n\\n fn into_module_item(self) -> ModuleItem {\\n match self.into_module_decl() {\\n Ok(v) => ModuleItem::ModuleDecl(v),\\n Err(v) => ModuleItem::Stmt(v),\\n }\\n }\\n\\n fn into_module_decl(self) -> Result;\\n\\n fn as_stmt_mut(&mut self) -> Option<&mut Stmt>;\\n}\\n\\nimpl MoudleItemExt for Stmt {\\n fn as_module_decl(&self) -> Result<&ModuleDecl, &Stmt> {\\n Err(self)\\n }\\n\\n fn from_module_item(item: ModuleItem) -> Self {\\n item.expect_stmt()\\n }\\n\\n fn into_module_decl(self) -> Result {\\n Err(self)\\n }\\n\\n fn as_stmt_mut(&mut self) -> Option<&mut Stmt> {\\n Some(self)\\n }\\n}\\n\\nimpl MoudleItemExt for ModuleItem {\\n fn as_module_decl(&self) -> Result<&ModuleDecl, &Stmt> {\\n match self {\\n ModuleItem::ModuleDecl(v) => Ok(v),\\n ModuleItem::Stmt(v) => Err(v),\\n }\\n }\\n\\n fn from_module_item(item: ModuleItem) -> Self {\\n item\\n }\\n\\n fn into_module_decl(self) -> Result {\\n match self {\\n ModuleItem::ModuleDecl(v) => Ok(v),\\n ModuleItem::Stmt(v) => Err(v),\\n }\\n }\\n\\n fn as_stmt_mut(&mut self) -> Option<&mut Stmt> {\\n match self {\\n ModuleItem::ModuleDecl(_) => None,\\n ModuleItem::Stmt(s) => Some(s),\\n }\\n }\\n}\\n\\n///\\n/// - `!0` for true\\n/// - `!1` for false\\npub(crate) fn make_bool(span: Span, value: bool) -> Expr {\\n if cfg!(feature = \"debug\") {\\n tracing::debug!(\"Creating a boolean literal\");\\n }\\n Expr::Unary(UnaryExpr {\\n span,\\n op: op!(\"!\"),\\n arg: Box::new(Expr::Lit(Lit::Num(Number {\\n span: DUMMY_SP,\\n value: if value { 0.0 } else { 1.0 },\\n }))),\\n })\\n}\\n\\n/// Addditional methods for optimizing expressions.\\npub(crate) trait ExprOptExt: Sized {\\n fn as_expr(&self) -> &Expr;\\n fn as_mut(&mut self) -> &mut Expr;\\n\\n fn first_expr_mut(&mut self) -> &mut Expr {\\n let expr = self.as_mut();\\n match expr {\\n Expr::Seq(seq) => seq\\n .exprs\\n .first_mut()\\n .expect(\"Sequence expressions should have at least one element\")\\n .first_expr_mut(),\\n expr => expr,\\n }\\n }\\n\\n /// This returns itself for normal expressions and returns last exprssions\\n /// for sequence expressions.\\n fn value_mut(&mut self) -> &mut Expr {\\n let expr = self.as_mut();\\n match expr {\\n Expr::Seq(seq) => seq\\n .exprs\\n .last_mut()\\n .expect(\"Sequence expressions should have at least one element\")\\n .value_mut(),\\n expr => expr,\\n }\\n }\\n\\n fn force_seq(&mut self) -> &mut SeqExpr {\\n let expr = self.as_mut();\\n match expr {\\n Expr::Seq(seq) => seq,\\n _ => {\\n let inner = expr.take();\\n *expr = Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs: vec![Box::new(inner)],\\n });\\n expr.force_seq()\\n }\\n }\\n }\\n\\n #[inline]\\n fn prepend_exprs(&mut self, mut exprs: Vec>) {\\n if exprs.is_empty() {\\n return;\\n }\\n\\n let to = self.as_mut();\\n match to {\\n Expr::Seq(to) => {\\n exprs.append(&mut to.exprs);\\n to.exprs = exprs;\\n }\\n _ => {\\n let v = to.take();\\n exprs.push(Box::new(v));\\n *to = Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs,\\n });\\n }\\n }\\n }\\n}\\n\\nimpl ExprOptExt for Box {\\n #[inline]\\n fn as_expr(&self) -> &Expr {\\n &self\\n }\\n\\n #[inline]\\n fn as_mut(&mut self) -> &mut Expr {\\n self\\n }\\n}\\n\\nimpl ExprOptExt for Expr {\\n #[inline]\\n fn as_expr(&self) -> &Expr {\\n self\\n }\\n\\n #[inline]\\n fn as_mut(&mut self) -> &mut Expr {\\n self\\n }\\n}\\n\\npub(crate) trait SpanExt: Into {\\n fn with_mark(self, mark: Mark) -> Span {\\n let span = self.into();\\n span.apply_mark(mark)\\n }\\n}\\n\\nimpl SpanExt for Span {}\\n\\npub(crate) fn contains_leaping_yield(n: &N) -> bool\\nwhere\\n N: VisitWith,\\n{\\n let mut v = LeapFinder::default();\\n n.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n v.found_yield\\n}\\n\\n#[derive(Default)]\\npub(crate) struct LeapFinder {\\n found_yield: bool,\\n}\\n\\nimpl Visit for LeapFinder {\\n noop_visit_type!();\\n\\n fn visit_yield_expr(&mut self, _: &YieldExpr, _: &dyn Node) {\\n self.found_yield = true;\\n }\\n\\n fn visit_function(&mut self, _: &Function, _: &dyn Node) {}\\n fn visit_arrow_expr(&mut self, _: &ArrowExpr, _: &dyn Node) {}\\n}\\n\\n/// This method returns true only if `T` is `var`. (Not `const` or `let`)\\npub(crate) fn is_hoisted_var_decl_without_init(t: &T) -> bool\\nwhere\\n T: StmtLike,\\n{\\n let var = match t.as_stmt() {\\n Some(Stmt::Decl(Decl::Var(\\n v @ VarDecl {\\n kind: VarDeclKind::Var,\\n ..\\n },\\n ))) => v,\\n _ => return false,\\n };\\n var.decls.iter().all(|decl| decl.init.is_none())\\n}\\n\\npub(crate) trait IsModuleItem {\\n fn is_module_item() -> bool;\\n}\\n\\nimpl IsModuleItem for Stmt {\\n #[inline]\\n fn is_module_item() -> bool {\\n false\\n }\\n}\\n\\nimpl IsModuleItem for ModuleItem {\\n #[inline]\\n fn is_module_item() -> bool {\\n true\\n }\\n}\\n\\npub trait ValueExt: Into> {\\n fn opt(self) -> Option {\\n match self.into() {\\n Value::Known(v) => Some(v),\\n _ => None,\\n }\\n }\\n}\\n\\nimpl ValueExt for Value {}\\n\\n/// TODO(kdy1): Modify swc_visit.\\n/// Actually we should implement `swc_visit::Repeated` for\\n/// `swc_visit::Optional`. But I\\'m too lazy to bump versions.\\npub(crate) struct Optional {\\n pub enabled: bool,\\n pub visitor: V,\\n}\\n\\nimpl Repeated for Optional\\nwhere\\n V: Repeated,\\n{\\n #[inline]\\n fn changed(&self) -> bool {\\n if self.enabled {\\n return false;\\n }\\n\\n self.visitor.changed()\\n }\\n\\n #[inline]\\n fn reset(&mut self) {\\n if self.enabled {\\n return;\\n }\\n\\n self.visitor.reset()\\n }\\n}\\n\\nimpl CompilerPass for Optional\\nwhere\\n V: CompilerPass,\\n{\\n fn name() -> std::borrow::Cow<\\'static, str> {\\n V::name()\\n }\\n}\\n\\nimpl Fold for Optional\\nwhere\\n V: Fold,\\n{\\n #[inline(always)]\\n fn fold_module(&mut self, module: Module) -> Module {\\n if !self.enabled {\\n return module;\\n }\\n module.fold_with(&mut self.visitor)\\n }\\n}\\n\\npub struct DeepThisExprVisitor {\\n found: bool,\\n}\\n\\nimpl Visit for DeepThisExprVisitor {\\n noop_visit_type!();\\n\\n fn visit_this_expr(&mut self, _: &ThisExpr, _: &dyn Node) {\\n self.found = true;\\n }\\n}\\n\\npub fn deeply_contains_this_expr(body: &N) -> bool\\nwhere\\n N: VisitWith,\\n{\\n let mut visitor = DeepThisExprVisitor { found: false };\\n body.visit_with(&Invalid { span: DUMMY_SP } as _, &mut visitor);\\n visitor.found\\n}\\n\\n#[derive(Default)]\\npub(crate) struct IdentUsageCollector {\\n ids: FxHashSet,\\n ignore_nested: bool,\\n}\\n\\nimpl Visit for IdentUsageCollector {\\n noop_visit_type!();\\n\\n fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr, _: &dyn Node) {\\n if self.ignore_nested {\\n return;\\n }\\n\\n n.visit_children_with(self);\\n }\\n\\n fn visit_constructor(&mut self, n: &Constructor, _: &dyn Node) {\\n if self.ignore_nested {\\n return;\\n }\\n\\n n.visit_children_with(self);\\n }\\n\\n fn visit_function(&mut self, n: &Function, _: &dyn Node) {\\n if self.ignore_nested {\\n return;\\n }\\n\\n n.visit_children_with(self);\\n }\\n\\n fn visit_ident(&mut self, n: &Ident, _: &dyn Node) {\\n self.ids.insert(n.to_id());\\n }\\n\\n fn visit_member_expr(&mut self, n: &MemberExpr, _: &dyn Node) {\\n n.obj.visit_with(n, self);\\n\\n if n.computed {\\n n.prop.visit_with(n, self);\\n }\\n }\\n\\n fn visit_prop_name(&mut self, n: &PropName, _: &dyn Node) {\\n match n {\\n PropName::Computed(..) => {\\n n.visit_children_with(self);\\n }\\n _ => {}\\n }\\n }\\n}\\n\\npub(crate) fn idents_used_by(n: &N) -> FxHashSet\\nwhere\\n N: VisitWith,\\n{\\n let mut v = IdentUsageCollector {\\n ignore_nested: false,\\n ..Default::default()\\n };\\n n.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n v.ids\\n}\\n\\npub(crate) fn idents_used_by_ignoring_nested(n: &N) -> FxHashSet\\nwhere\\n N: VisitWith,\\n{\\n let mut v = IdentUsageCollector {\\n ignore_nested: true,\\n ..Default::default()\\n };\\n n.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n v.ids\\n}\\n\\npub(crate) fn can_end_conditionally(s: &Stmt) -> bool {\\n ///\\n ///`ignore_always`: If true, [Stmt::Return] will be ignored.\\n fn can_end(s: &Stmt, ignore_always: bool) -> bool {\\n match s {\\n Stmt::If(s) => {\\n can_end(&s.cons, false)\\n || s.alt\\n .as_deref()\\n .map(|s| can_end(s, false))\\n .unwrap_or_default()\\n }\\n\\n Stmt::Switch(s) => s\\n .cases\\n .iter()\\n .any(|case| case.cons.iter().any(|s| can_end(&s, false))),\\n\\n Stmt::DoWhile(s) => can_end(&s.body, false),\\n\\n Stmt::While(s) => can_end(&s.body, false),\\n\\n Stmt::For(s) => can_end(&s.body, false),\\n\\n Stmt::ForOf(s) => can_end(&s.body, false),\\n\\n Stmt::ForIn(s) => can_end(&s.body, false),\\n\\n Stmt::Return(..) | Stmt::Break(..) | Stmt::Continue(..) => !ignore_always,\\n\\n _ => false,\\n }\\n }\\n\\n can_end(s, true)\\n}\\n\\npub fn now() -> Option {\\n if cfg!(target_arch = \"wasm32\") {\\n None\\n } else {\\n Some(Instant::now())\\n }\\n}\\n',\n", + " 'content_id': 'd82f84024baba48ac51257c105df04ff3c9a3abd',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 86,\n", + " 'path': '/ecmascript/minifier/src/util/mod.rs',\n", + " 'size': 10939,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5512820512820513,\n", + " 'avg_line_length': 26.962264150943398,\n", + " 'blob_id': 'e9a6ecd3211c71f20ec81e1bf4d88e774b78f822',\n", + " 'content': 'use crate::bundler::tests::suite;\\nuse ahash::AHashMap;\\nuse rustc_hash::{FxHashMap, FxHashSet};\\nuse std::collections::HashMap;\\n\\nfn assert_cycles(map: FxHashMap, cycle_entries: Vec<&str>) {\\n let mut tester = suite();\\n\\n for (k, v) in map {\\n tester = tester.file(&k, &v);\\n }\\n\\n tester.run(|tester| {\\n let mut entries = AHashMap::default();\\n entries.insert(\"main.js\".to_string(), tester.module(\"main.js\"));\\n let (_plan, _graph, cycles) = tester.bundler.determine_entries(entries).unwrap();\\n\\n dbg!(&cycles);\\n\\n let actual: FxHashSet<_> = cycles.into_iter().flatten().collect();\\n\\n let expected: FxHashSet<_> = cycle_entries\\n .iter()\\n .map(|name| tester.module(&name).id)\\n .collect();\\n\\n assert_eq!(expected, actual);\\n\\n Ok(())\\n });\\n}\\n\\n#[test]\\nfn deno_10820_1() {\\n let mut map = HashMap::default();\\n map.insert(\"main.js\".to_string(), \"import \\'./router.js\\'\".to_string());\\n map.insert(\"data.js\".to_string(), \"import \\'./main.js\\'\".to_string());\\n map.insert(\"page1.js\".to_string(), \"import \\'./data.js\\'\".to_string());\\n map.insert(\"page2.js\".to_string(), \"import \\'./data.js\\'\".to_string());\\n map.insert(\\n \"router.js\".to_string(),\\n \"\\n import \\'./page1.js\\'\\n import \\'./page2.js\\'\\n \"\\n .to_string(),\\n );\\n\\n assert_cycles(\\n map,\\n vec![\"main.js\", \"data.js\", \"page1.js\", \"page2.js\", \"router.js\"],\\n );\\n}\\n',\n", + " 'content_id': 'aef5dcdabfcdc70312eb701bc20f2f4f7429d143',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 89,\n", + " 'path': '/bundler/src/bundler/chunk/plan/tests.rs',\n", + " 'size': 1482,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4737953303527074,\n", + " 'avg_line_length': 27.654804270462634,\n", + " 'blob_id': '321b519a07d32fe2b130b0883f16db14446c736e',\n", + " 'content': 'use crate::ModuleId;\\nuse retain_mut::RetainMut;\\nuse rustc_hash::FxHashMap;\\nuse std::mem::take;\\nuse swc_common::{SourceMap, SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_visit::{Fold, FoldWith, Visit, VisitMut, VisitMutWith, VisitWith};\\n\\nmod sort;\\n\\n#[derive(Debug, Clone)]\\npub struct Modules {\\n /// Indicates that a statement is injected.\\n ///\\n /// Note: This context shoulod be shared for a bundle.\\n pub(crate) injected_ctxt: SyntaxContext,\\n\\n // We will change this into `Vec`.\\n modules: Vec<(ModuleId, Module)>,\\n prepended_stmts: FxHashMap>,\\n appended_stmts: FxHashMap>,\\n}\\n\\nimpl Modules {\\n pub fn empty(injected_ctxt: SyntaxContext) -> Self {\\n Self {\\n injected_ctxt,\\n modules: Default::default(),\\n prepended_stmts: Default::default(),\\n appended_stmts: Default::default(),\\n }\\n }\\n\\n pub fn from(id: ModuleId, module: Module, injected_ctxt: SyntaxContext) -> Self {\\n let mut ret = Self::empty(injected_ctxt);\\n ret.modules.push((id, module));\\n ret\\n }\\n\\n fn into_items(self) -> Vec {\\n debug_assert!(\\n self.prepended_stmts.is_empty(),\\n \"sort should be called before calling into_items\"\\n );\\n debug_assert!(\\n self.appended_stmts.is_empty(),\\n \"sort should be called before calling into_items\"\\n );\\n self.modules.into_iter().flat_map(|v| v.1.body).collect()\\n }\\n\\n pub fn add_dep(&mut self, dep: Modules) {\\n self.push_all(dep)\\n }\\n\\n pub fn push_all(&mut self, other: Modules) {\\n for (id, stmts) in other.prepended_stmts {\\n self.prepended_stmts.entry(id).or_default().extend(stmts);\\n }\\n\\n for (id, stmts) in other.appended_stmts {\\n self.appended_stmts.entry(id).or_default().extend(stmts);\\n }\\n\\n for (id, module) in other.modules {\\n if let Some(prev) = self.modules.iter_mut().find(|prev| prev.0 == id) {\\n prev.1.body.extend(module.body);\\n } else {\\n self.modules.push((id, module));\\n }\\n }\\n }\\n\\n pub fn iter(&self) -> impl Iterator {\\n self.prepended_stmts\\n .iter()\\n .flat_map(|(id, stmts)| stmts.iter().map(move |stmt| (*id, stmt)))\\n .chain(\\n self.modules\\n .iter()\\n .flat_map(|(id, m)| m.body.iter().map(move |v| (*id, v))),\\n )\\n .chain(\\n self.appended_stmts\\n .iter()\\n .flat_map(|(id, stmts)| stmts.iter().map(move |stmt| (*id, stmt))),\\n )\\n }\\n\\n pub fn iter_mut(&mut self) -> impl Iterator {\\n self.prepended_stmts\\n .iter_mut()\\n .flat_map(|(id, stmts)| stmts.iter_mut().map(move |stmt| (*id, stmt)))\\n .chain(\\n self.modules\\n .iter_mut()\\n .flat_map(|(id, m)| m.body.iter_mut().map(move |v| (*id, v))),\\n )\\n .chain(\\n self.appended_stmts\\n .iter_mut()\\n .flat_map(|(id, stmts)| stmts.iter_mut().map(move |stmt| (*id, stmt))),\\n )\\n }\\n\\n pub fn map_any_items(&mut self, mut op: F)\\n where\\n F: FnMut(ModuleId, Vec) -> Vec,\\n {\\n let p = take(&mut self.prepended_stmts);\\n self.prepended_stmts = p\\n .into_iter()\\n .map(|(id, items)| (id, op(id, items)))\\n .collect();\\n\\n self.modules = take(&mut self.modules)\\n .into_iter()\\n .map(|mut m| {\\n let body = op(m.0, take(&mut m.1.body));\\n\\n (m.0, Module { body, ..m.1 })\\n })\\n .collect();\\n\\n let a = take(&mut self.appended_stmts);\\n self.appended_stmts = a\\n .into_iter()\\n .map(|(id, items)| (id, op(id, items)))\\n .collect();\\n }\\n\\n pub fn map_items_mut(&mut self, mut op: F)\\n where\\n F: FnMut(ModuleId, &mut ModuleItem),\\n {\\n self.iter_mut().for_each(|(id, item)| op(id, item))\\n }\\n\\n pub fn append_all(&mut self, items: impl IntoIterator) {\\n for v in items {\\n self.append(v.0, v.1);\\n }\\n }\\n\\n pub fn append(&mut self, module_id: ModuleId, item: ModuleItem) {\\n self.appended_stmts.entry(module_id).or_default().push(item);\\n }\\n\\n pub fn prepend(&mut self, module_id: ModuleId, item: ModuleItem) {\\n self.prepended_stmts\\n .entry(module_id)\\n .or_default()\\n .push(item);\\n }\\n\\n pub fn visit_mut_with(&mut self, v: &mut V)\\n where\\n V: VisitMut,\\n {\\n self.iter_mut().for_each(|item| item.1.visit_mut_with(v));\\n }\\n\\n pub fn fold_with(mut self, v: &mut V) -> Self\\n where\\n V: Fold,\\n {\\n self.prepended_stmts = self\\n .prepended_stmts\\n .into_iter()\\n .map(|(id, items)| (id, items.fold_with(&mut *v)))\\n .collect();\\n self.modules = self\\n .modules\\n .into_iter()\\n .map(|m| (m.0, m.1.fold_with(&mut *v)))\\n .collect();\\n\\n self.appended_stmts = self\\n .appended_stmts\\n .into_iter()\\n .map(|(id, items)| (id, items.fold_with(&mut *v)))\\n .collect();\\n\\n self\\n }\\n\\n pub fn visit_with(&self, v: &mut V)\\n where\\n V: Visit,\\n {\\n self.iter()\\n .for_each(|item| item.1.visit_with(&Invalid { span: DUMMY_SP }, v));\\n }\\n\\n pub fn retain_mut(&mut self, mut op: F)\\n where\\n F: FnMut(ModuleId, &mut ModuleItem) -> bool,\\n {\\n self.prepended_stmts\\n .iter_mut()\\n .for_each(|(id, v)| v.retain_mut(|item| op(*id, item)));\\n\\n for module in &mut self.modules {\\n let id = module.0;\\n module.1.body.retain_mut(|item| op(id, item));\\n }\\n\\n self.appended_stmts\\n .iter_mut()\\n .for_each(|(id, v)| v.retain_mut(|item| op(*id, item)));\\n }\\n\\n #[allow(unused)]\\n #[cfg(debug_assertions)]\\n pub(crate) fn print(\\n &self,\\n cm: &swc_common::sync::Lrc,\\n event: impl std::fmt::Display,\\n ) {\\n let files = self\\n .modules\\n .iter()\\n .map(|(_, m)| m.span)\\n .filter_map(|module_span| {\\n if module_span.is_dummy() {\\n return None;\\n }\\n Some(format!(\\n \"{}\\\\n\",\\n cm.lookup_source_file(module_span.lo).name.to_string()\\n ))\\n })\\n .collect::();\\n let mut cloned = self.clone();\\n let mut stmts = vec![];\\n\\n for (id, mut module) in cloned.modules {\\n swc_ecma_utils::prepend_stmts(\\n &mut module.body,\\n cloned\\n .prepended_stmts\\n .get(&id)\\n .cloned()\\n .unwrap_or_default()\\n .into_iter(),\\n );\\n\\n module.body.extend(\\n cloned\\n .appended_stmts\\n .get(&id)\\n .cloned()\\n .unwrap_or_default()\\n .into_iter(),\\n );\\n\\n stmts.extend(module.body);\\n }\\n\\n crate::debug::print_hygiene(\\n &format!(\"{}\\\\n{}\", event, files),\\n cm,\\n &Module {\\n span: DUMMY_SP,\\n body: stmts,\\n shebang: None,\\n },\\n );\\n }\\n}\\n\\nimpl From for Module {\\n fn from(modules: Modules) -> Self {\\n // TODO\\n Self {\\n span: DUMMY_SP,\\n body: modules.into_items(),\\n shebang: None,\\n }\\n }\\n}\\n',\n", + " 'content_id': '04744047ccb8112ff89dfc99aed8e4ba54572382',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 91,\n", + " 'path': '/bundler/src/modules/mod.rs',\n", + " 'size': 8052,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4333418985800311,\n", + " 'avg_line_length': 27.424579231502065,\n", + " 'blob_id': '901456bbc7924a43d3becc1e1628af294f20232f',\n", + " 'content': '#![recursion_limit = \"1024\"]\\n#![allow(unused_variables)]\\n\\npub use self::config::Config;\\nuse self::{\\n list::ListFormat,\\n text_writer::WriteJs,\\n util::{SourceMapperExt, SpanExt, StartsWithAlphaNum},\\n};\\nuse crate::util::EndsWithAlphaNum;\\nuse memchr::memmem::Finder;\\nuse once_cell::sync::Lazy;\\nuse std::{borrow::Cow, fmt::Write, io, sync::Arc};\\nuse swc_atoms::JsWord;\\nuse swc_common::{\\n comments::Comments, sync::Lrc, BytePos, SourceMap, Span, Spanned, SyntaxContext, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_codegen_macros::emitter;\\nuse swc_ecma_parser::JscTarget;\\n\\n#[macro_use]\\npub mod macros;\\nmod comments;\\nmod config;\\nmod decl;\\nmod expr;\\nmod jsx;\\npub mod list;\\nmod stmt;\\n#[cfg(test)]\\nmod tests;\\npub mod text_writer;\\nmod typescript;\\npub mod util;\\n\\npub type Result = io::Result<()>;\\n\\npub trait Node: Spanned {\\n fn emit_with(&self, e: &mut Emitter<\\'_, W>) -> Result\\n where\\n W: WriteJs;\\n}\\nimpl Node for Box {\\n #[inline]\\n fn emit_with(&self, e: &mut Emitter<\\'_, W>) -> Result\\n where\\n W: WriteJs,\\n {\\n (**self).emit_with(e)\\n }\\n}\\nimpl<\\'a, N: Node> Node for &\\'a N {\\n #[inline]\\n fn emit_with(&self, e: &mut Emitter<\\'_, W>) -> Result\\n where\\n W: WriteJs,\\n {\\n (**self).emit_with(e)\\n }\\n}\\n\\npub struct Emitter<\\'a, W>\\nwhere\\n W: WriteJs,\\n{\\n pub cfg: config::Config,\\n pub cm: Lrc,\\n pub comments: Option<&\\'a dyn Comments>,\\n pub wr: W,\\n}\\n\\nimpl<\\'a, W> Emitter<\\'a, W>\\nwhere\\n W: WriteJs,\\n{\\n #[emitter]\\n pub fn emit_program(&mut self, node: &Program) -> Result {\\n match *node {\\n Program::Module(ref m) => emit!(m),\\n Program::Script(ref s) => emit!(s),\\n }\\n }\\n\\n #[emitter]\\n pub fn emit_module(&mut self, node: &Module) -> Result {\\n if let Some(ref shebang) = node.shebang {\\n punct!(\"#!\");\\n self.wr.write_str_lit(DUMMY_SP, &*shebang)?;\\n self.wr.write_line()?;\\n }\\n for stmt in &node.body {\\n emit!(stmt);\\n }\\n }\\n\\n #[emitter]\\n pub fn emit_script(&mut self, node: &Script) -> Result {\\n if let Some(ref shebang) = node.shebang {\\n punct!(\"#!\");\\n self.wr.write_str_lit(DUMMY_SP, &*shebang)?;\\n self.wr.write_line()?;\\n }\\n for stmt in &node.body {\\n emit!(stmt);\\n }\\n }\\n\\n #[emitter]\\n pub fn emit_module_item(&mut self, node: &ModuleItem) -> Result {\\n match *node {\\n ModuleItem::Stmt(ref stmt) => emit!(stmt),\\n ModuleItem::ModuleDecl(ref decl) => emit!(decl),\\n }\\n }\\n\\n #[emitter]\\n fn emit_module_decl(&mut self, node: &ModuleDecl) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n match *node {\\n ModuleDecl::Import(ref d) => emit!(d),\\n ModuleDecl::ExportDecl(ref d) => emit!(d),\\n ModuleDecl::ExportNamed(ref d) => emit!(d),\\n ModuleDecl::ExportDefaultDecl(ref d) => emit!(d),\\n ModuleDecl::ExportDefaultExpr(ref n) => emit!(n),\\n ModuleDecl::ExportAll(ref d) => emit!(d),\\n ModuleDecl::TsExportAssignment(ref n) => emit!(n),\\n ModuleDecl::TsImportEquals(ref n) => emit!(n),\\n ModuleDecl::TsNamespaceExport(ref n) => emit!(n),\\n }\\n\\n self.emit_trailing_comments_of_pos(node.span().hi, true, true)?;\\n\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n }\\n\\n #[emitter]\\n fn emit_export_decl(&mut self, node: &ExportDecl) -> Result {\\n keyword!(\"export\");\\n space!();\\n emit!(node.decl);\\n }\\n\\n #[emitter]\\n fn emit_export_default_expr(&mut self, node: &ExportDefaultExpr) -> Result {\\n keyword!(\"export\");\\n space!();\\n keyword!(\"default\");\\n {\\n let starts_with_alpha_num = node.expr.starts_with_alpha_num();\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n emit!(node.expr);\\n }\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_export_default_decl(&mut self, node: &ExportDefaultDecl) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"export\");\\n space!();\\n keyword!(\"default\");\\n space!();\\n match node.decl {\\n DefaultDecl::Class(ref n) => emit!(n),\\n DefaultDecl::Fn(ref n) => emit!(n),\\n DefaultDecl::TsInterfaceDecl(ref n) => emit!(n),\\n }\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_import(&mut self, node: &ImportDecl) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"import\");\\n let starts_with_ident = !node.specifiers.is_empty()\\n && match &node.specifiers[0] {\\n ImportSpecifier::Default(_) => true,\\n _ => false,\\n };\\n if starts_with_ident {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n\\n let mut specifiers = vec![];\\n let mut emitted_default = false;\\n let mut emitted_ns = false;\\n for specifier in &node.specifiers {\\n match specifier {\\n ImportSpecifier::Named(ref s) => {\\n specifiers.push(s);\\n }\\n ImportSpecifier::Default(ref s) => {\\n emit!(s.local);\\n emitted_default = true;\\n }\\n ImportSpecifier::Namespace(ref ns) => {\\n if emitted_default {\\n punct!(\",\");\\n formatting_space!();\\n }\\n\\n emitted_ns = true;\\n\\n assert!(node.specifiers.len() <= 2);\\n punct!(\"*\");\\n formatting_space!();\\n keyword!(\"as\");\\n space!();\\n emit!(ns.local);\\n }\\n }\\n }\\n\\n if specifiers.is_empty() {\\n if emitted_ns || emitted_default {\\n space!();\\n keyword!(\"from\");\\n formatting_space!();\\n }\\n } else {\\n if emitted_default {\\n punct!(\",\");\\n formatting_space!();\\n }\\n\\n punct!(\"{\");\\n self.emit_list(\\n node.span(),\\n Some(&specifiers),\\n ListFormat::NamedImportsOrExportsElements,\\n )?;\\n punct!(\"}\");\\n formatting_space!();\\n\\n keyword!(\"from\");\\n formatting_space!();\\n }\\n\\n emit!(node.src);\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_import_specific(&mut self, node: &ImportNamedSpecifier) -> Result {\\n if let Some(ref imported) = node.imported {\\n emit!(imported);\\n space!();\\n keyword!(\"as\");\\n space!();\\n }\\n\\n emit!(node.local);\\n }\\n\\n #[emitter]\\n fn emit_export_specifier(&mut self, node: &ExportSpecifier) -> Result {\\n match node {\\n ExportSpecifier::Default(ref node) => {\\n unimplemented!(\"codegen of `export default from \\'foo\\';`\")\\n }\\n ExportSpecifier::Namespace(ref node) => emit!(node),\\n ExportSpecifier::Named(ref node) => emit!(node),\\n }\\n }\\n\\n #[emitter]\\n fn emit_namespace_export_specifier(&mut self, node: &ExportNamespaceSpecifier) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n punct!(\"*\");\\n formatting_space!();\\n keyword!(\"as\");\\n space!();\\n emit!(node.name);\\n }\\n\\n #[emitter]\\n fn emit_named_export_specifier(&mut self, node: &ExportNamedSpecifier) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n if let Some(ref exported) = node.exported {\\n emit!(node.orig);\\n space!();\\n keyword!(\"as\");\\n space!();\\n emit!(node.exported);\\n } else {\\n emit!(node.orig);\\n }\\n }\\n\\n #[emitter]\\n fn emit_named_export(&mut self, node: &NamedExport) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n struct Specifiers<\\'a> {\\n has_namespace_spec: bool,\\n namespace_spec: Option<&\\'a ExportNamespaceSpecifier>,\\n has_named_specs: bool,\\n named_specs: Vec<&\\'a ExportSpecifier>,\\n }\\n let Specifiers {\\n has_namespace_spec,\\n namespace_spec,\\n has_named_specs,\\n named_specs,\\n } = node.specifiers.iter().fold(\\n Specifiers {\\n has_namespace_spec: false,\\n namespace_spec: None,\\n has_named_specs: false,\\n named_specs: vec![],\\n },\\n |mut result, s| match s {\\n ExportSpecifier::Namespace(spec) => {\\n result.has_namespace_spec = true;\\n // There can only be one namespace export specifier.\\n if let None = result.namespace_spec {\\n result.namespace_spec = Some(spec)\\n }\\n result\\n }\\n spec => {\\n result.has_named_specs = true;\\n result.named_specs.push(spec);\\n result\\n }\\n },\\n );\\n\\n keyword!(\"export\");\\n formatting_space!();\\n if let Some(spec) = namespace_spec {\\n emit!(spec);\\n if has_named_specs {\\n punct!(\",\");\\n formatting_space!();\\n }\\n }\\n if has_named_specs || (!has_namespace_spec && !has_named_specs) {\\n punct!(\"{\");\\n self.emit_list(\\n node.span,\\n Some(&named_specs),\\n ListFormat::NamedImportsOrExportsElements,\\n )?;\\n punct!(\"}\");\\n }\\n\\n if let Some(ref src) = node.src {\\n if has_named_specs || (!has_namespace_spec && !has_named_specs) {\\n formatting_space!();\\n } else if has_namespace_spec {\\n space!();\\n }\\n keyword!(\"from\");\\n formatting_space!();\\n emit!(src);\\n }\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_export_all(&mut self, node: &ExportAll) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"export\");\\n formatting_space!();\\n punct!(\"*\");\\n formatting_space!();\\n keyword!(\"from\");\\n formatting_space!();\\n emit!(node.src);\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_lit(&mut self, node: &Lit) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n match *node {\\n Lit::Bool(Bool { value, span }) => {\\n if value {\\n keyword!(span, \"true\")\\n } else {\\n keyword!(span, \"false\")\\n }\\n }\\n Lit::Null(Null { span }) => keyword!(span, \"null\"),\\n Lit::Str(ref s) => emit!(s),\\n Lit::BigInt(ref s) => emit!(s),\\n Lit::Num(ref n) => emit!(n),\\n Lit::Regex(ref n) => {\\n punct!(\"/\");\\n self.wr.write_str(&n.exp)?;\\n punct!(\"/\");\\n self.wr.write_str(&n.flags)?;\\n }\\n Lit::JSXText(ref n) => emit!(n),\\n }\\n }\\n\\n fn emit_js_word(&mut self, span: Span, value: &JsWord) -> Result {\\n self.wr.write_str_lit(span, &value)?;\\n\\n Ok(())\\n }\\n\\n #[emitter]\\n fn emit_str_lit(&mut self, node: &Str) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n let (single_quote, value) = match node.kind {\\n StrKind::Normal { contains_quote } => {\\n let single_quote = if contains_quote {\\n is_single_quote(&self.cm, node.span)\\n } else {\\n None\\n };\\n\\n let value = escape_with_source(\\n &self.cm,\\n self.wr.target(),\\n node.span,\\n &node.value,\\n single_quote,\\n );\\n\\n (single_quote.unwrap_or(false), value)\\n }\\n StrKind::Synthesized => {\\n let single_quote = false;\\n let value = escape_without_source(&node.value, self.wr.target(), single_quote);\\n\\n (single_quote, value)\\n }\\n };\\n\\n if single_quote {\\n punct!(node.span, \"\\'\");\\n self.wr.write_str_lit(DUMMY_SP, &value)?;\\n punct!(\"\\'\");\\n } else {\\n punct!(node.span, \"\\\\\"\");\\n self.wr.write_str_lit(DUMMY_SP, &value)?;\\n punct!(\"\\\\\"\");\\n }\\n }\\n\\n #[emitter]\\n fn emit_num_lit(&mut self, num: &Number) -> Result {\\n self.emit_leading_comments_of_span(num.span(), false)?;\\n\\n // Handle infinity\\n if num.value.is_infinite() {\\n if num.value.is_sign_negative() {\\n self.wr.write_str_lit(num.span, \"-\")?;\\n }\\n self.wr.write_str_lit(num.span, \"Infinity\")?;\\n } else {\\n if num.value.is_sign_negative() && num.value == 0.0 {\\n self.wr.write_str_lit(num.span, \"-0\")?;\\n } else {\\n let mut s = num.value.to_string();\\n if self.cfg.minify {\\n if !s.contains(\\'.\\') && !s.contains(\\'e\\') && s.ends_with(\"0000\") {\\n let cnt = s.as_bytes().iter().rev().filter(|&&v| v == b\\'0\\').count() - 1;\\n\\n s.truncate(s.len() - cnt);\\n s.push(\\'e\\');\\n s.push_str(&cnt.to_string());\\n }\\n }\\n\\n self.wr.write_str_lit(num.span, &s)?;\\n }\\n }\\n }\\n\\n #[emitter]\\n fn emit_big_lit(&mut self, v: &BigInt) -> Result {\\n self.emit_leading_comments_of_span(v.span, false)?;\\n\\n self.wr.write_lit(v.span, &v.value.to_string())?;\\n self.wr.write_lit(v.span, \"n\")?;\\n }\\n\\n // fn emit_object_binding_pat(&mut self, node: &ObjectPat) -> Result {\\n // self.wr.write_punct(\"{\")?;\\n // self.emit_list(\\n // node.span(),\\n // &node.props,\\n // ListFormat::ObjectBindingPatternElements,\\n // );\\n // self.wr.write_punct(\"}\")?;\\n\\n // Ok(())\\n // }\\n\\n // fn emit_array_binding_pat(&mut self, node: &ArrayPat) -> Result {\\n // self.wr.write_punct(\"[\")?;\\n // self.emit_list(\\n // node.span(),\\n // &node.elems,\\n // ListFormat::ArrayBindingPatternElements,\\n // );\\n // self.wr.write_punct(\"]\")?;\\n\\n // Ok(())\\n // }\\n\\n #[emitter]\\n fn emit_expr_or_super(&mut self, node: &ExprOrSuper) -> Result {\\n match *node {\\n ExprOrSuper::Expr(ref e) => emit!(e),\\n ExprOrSuper::Super(ref n) => emit!(n),\\n }\\n }\\n #[emitter]\\n fn emit_super(&mut self, node: &Super) -> Result {\\n keyword!(node.span, \"super\");\\n }\\n\\n #[emitter]\\n fn emit_expr(&mut self, node: &Expr) -> Result {\\n match *node {\\n Expr::Array(ref n) => emit!(n),\\n Expr::Arrow(ref n) => emit!(n),\\n Expr::Assign(ref n) => emit!(n),\\n Expr::Await(ref n) => emit!(n),\\n Expr::Bin(ref n) => emit!(n),\\n Expr::Call(ref n) => emit!(n),\\n Expr::Class(ref n) => emit!(n),\\n Expr::Cond(ref n) => emit!(n),\\n Expr::Fn(ref n) => emit!(n),\\n Expr::Ident(ref n) => emit!(n),\\n Expr::Lit(ref n) => emit!(n),\\n Expr::Member(ref n) => emit!(n),\\n Expr::MetaProp(ref n) => emit!(n),\\n Expr::New(ref n) => emit!(n),\\n Expr::Object(ref n) => emit!(n),\\n Expr::Paren(ref n) => emit!(n),\\n Expr::Seq(ref n) => emit!(n),\\n Expr::TaggedTpl(ref n) => emit!(n),\\n Expr::This(ref n) => emit!(n),\\n Expr::Tpl(ref n) => emit!(n),\\n Expr::Unary(ref n) => emit!(n),\\n Expr::Update(ref n) => emit!(n),\\n Expr::Yield(ref n) => emit!(n),\\n Expr::PrivateName(ref n) => emit!(n),\\n\\n Expr::JSXMember(ref n) => emit!(n),\\n Expr::JSXNamespacedName(ref n) => emit!(n),\\n Expr::JSXEmpty(ref n) => emit!(n),\\n Expr::JSXElement(ref n) => emit!(n),\\n Expr::JSXFragment(ref n) => emit!(n),\\n\\n Expr::TsAs(ref n) => emit!(n),\\n Expr::TsNonNull(ref n) => emit!(n),\\n Expr::TsTypeAssertion(ref n) => emit!(n),\\n Expr::TsConstAssertion(ref n) => emit!(n),\\n Expr::OptChain(ref n) => emit!(n),\\n Expr::Invalid(ref n) => emit!(n),\\n }\\n\\n self.emit_trailing_comments_of_pos(node.span().hi, true, true)?;\\n }\\n\\n #[emitter]\\n fn emit_opt_chain(&mut self, n: &OptChainExpr) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n match *n.expr {\\n Expr::Member(ref e) => {\\n emit!(e.obj);\\n punct!(\"?.\");\\n\\n if e.computed {\\n punct!(\"[\");\\n emit!(e.prop);\\n punct!(\"]\");\\n } else {\\n emit!(e.prop);\\n }\\n }\\n Expr::Call(ref e) => {\\n emit!(e.callee);\\n punct!(\"?.\");\\n\\n punct!(\"(\");\\n self.emit_expr_or_spreads(n.span(), &e.args, ListFormat::CallExpressionArguments)?;\\n punct!(\")\");\\n }\\n _ => {}\\n }\\n }\\n\\n #[emitter]\\n fn emit_invalid(&mut self, n: &Invalid) -> Result {\\n self.emit_leading_comments_of_span(n.span, false)?;\\n\\n self.wr.write_str_lit(n.span, \"\")?;\\n }\\n\\n #[emitter]\\n fn emit_call_expr(&mut self, node: &CallExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.callee);\\n\\n punct!(\"(\");\\n self.emit_expr_or_spreads(node.span(), &node.args, ListFormat::CallExpressionArguments)?;\\n punct!(\")\");\\n }\\n\\n #[emitter]\\n fn emit_new_expr(&mut self, node: &NewExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n {\\n let span = self.cm.span_until_char(node.span, \\' \\');\\n keyword!(span, \"new\");\\n }\\n\\n let starts_with_alpha_num = node.callee.starts_with_alpha_num();\\n\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n emit!(node.callee);\\n\\n if let Some(type_args) = &node.type_args {\\n emit!(type_args);\\n }\\n\\n if let Some(ref args) = node.args {\\n punct!(\"(\");\\n self.emit_expr_or_spreads(node.span(), args, ListFormat::NewExpressionArguments)?;\\n punct!(\")\");\\n }\\n }\\n\\n #[emitter]\\n fn emit_member_expr(&mut self, node: &MemberExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.obj);\\n\\n if node.computed {\\n punct!(\"[\");\\n emit!(node.prop);\\n punct!(\"]\");\\n } else {\\n if self.needs_2dots_for_property_access(&node.obj) {\\n if node.prop.span().lo() >= BytePos(2) {\\n self.emit_leading_comments(node.prop.span().lo() - BytePos(2), false)?;\\n }\\n punct!(\".\");\\n }\\n if node.prop.span().lo() >= BytePos(1) {\\n self.emit_leading_comments(node.prop.span().lo() - BytePos(1), false)?;\\n }\\n punct!(\".\");\\n emit!(node.prop);\\n }\\n }\\n\\n /// `1..toString` is a valid property access, emit a dot after the literal\\n pub fn needs_2dots_for_property_access(&self, expr: &ExprOrSuper) -> bool {\\n match *expr {\\n ExprOrSuper::Expr(ref expr) => {\\n match **expr {\\n Expr::Lit(Lit::Num(Number { span, value })) => {\\n if value.fract() == 0.0 {\\n return true;\\n }\\n if span.is_dummy() {\\n return false;\\n }\\n\\n // check if numeric literal is a decimal literal that was originally written\\n // with a dot\\n if let Ok(text) = self.cm.span_to_snippet(span) {\\n if text.contains(\\'.\\') {\\n return false;\\n }\\n text.starts_with(\\'0\\') || text.ends_with(\\' \\')\\n } else {\\n true\\n }\\n }\\n _ => false,\\n }\\n }\\n _ => false,\\n }\\n }\\n\\n #[emitter]\\n fn emit_arrow_expr(&mut self, node: &ArrowExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n let space = !self.cfg.minify\\n || match node.params.as_slice() {\\n [Pat::Ident(_)] => true,\\n _ => false,\\n };\\n\\n if node.is_async {\\n keyword!(\"async\");\\n if space {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n }\\n if node.is_generator {\\n punct!(\"*\")\\n }\\n\\n let parens = !self.cfg.minify\\n || match node.params.as_slice() {\\n [Pat::Ident(_)] => false,\\n _ => true,\\n };\\n\\n emit!(node.type_params);\\n\\n if parens {\\n punct!(\"(\");\\n }\\n\\n self.emit_list(node.span, Some(&node.params), ListFormat::CommaListElements)?;\\n if parens {\\n punct!(\")\");\\n }\\n\\n punct!(\"=>\");\\n emit!(node.body);\\n }\\n\\n #[emitter]\\n fn emit_meta_prop_expr(&mut self, node: &MetaPropExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.meta);\\n punct!(\".\");\\n emit!(node.prop);\\n }\\n\\n #[emitter]\\n fn emit_seq_expr(&mut self, node: &SeqExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n let mut first = true;\\n //TODO: Indention\\n for e in &node.exprs {\\n if first {\\n first = false\\n } else {\\n punct!(\",\");\\n formatting_space!();\\n }\\n\\n emit!(e);\\n }\\n }\\n\\n #[emitter]\\n fn emit_assign_expr(&mut self, node: &AssignExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.left);\\n formatting_space!();\\n operator!(node.op.as_str());\\n formatting_space!();\\n emit!(node.right);\\n }\\n\\n /// Prints operator and right node of a binary expression.\\n #[inline(never)]\\n fn emit_bin_expr_trailing(&mut self, node: &BinExpr) -> Result {\\n // let indent_before_op = needs_indention(node, &node.left, node.op);\\n // let indent_after_op = needs_indention(node, node.op, &node.right);\\n let is_kwd_op = match node.op {\\n op!(\"in\") | op!(\"instanceof\") => true,\\n _ => false,\\n };\\n\\n let need_pre_space = if self.cfg.minify {\\n if is_kwd_op {\\n node.left.ends_with_alpha_num()\\n } else {\\n match *node.left {\\n Expr::Update(UpdateExpr { prefix: false, .. }) => true,\\n _ => false,\\n }\\n }\\n } else {\\n is_kwd_op\\n || match *node.left {\\n Expr::Update(UpdateExpr { prefix: false, .. }) => true,\\n _ => false,\\n }\\n };\\n if need_pre_space {\\n space!(self);\\n } else {\\n formatting_space!(self);\\n }\\n operator!(self, node.op.as_str());\\n\\n let need_post_space = if self.cfg.minify {\\n if is_kwd_op {\\n node.right.starts_with_alpha_num()\\n } else {\\n match (node.op, &*node.right) {\\n (\\n _,\\n Expr::Unary(UnaryExpr {\\n op: op!(\"typeof\") | op!(\"void\") | op!(\"delete\"),\\n ..\\n }),\\n ) => false,\\n\\n (op!(\"||\") | op!(\"&&\"), Expr::Unary(UnaryExpr { op: op!(\"!\"), .. })) => false,\\n\\n (op!(\"*\") | op!(\"/\"), Expr::Unary(..)) => false,\\n\\n (\\n op!(\"||\") | op!(\"&&\"),\\n Expr::Unary(UnaryExpr {\\n op: op!(unary, \"+\") | op!(unary, \"-\") | op!(\"!\"),\\n ..\\n }),\\n ) => false,\\n\\n (_, Expr::Update(UpdateExpr { prefix: true, .. }) | Expr::Unary(..)) => true,\\n\\n (_, Expr::Bin(BinExpr { left, .. })) => match &**left {\\n Expr::Update(UpdateExpr { prefix: true, .. }) | Expr::Unary(..) => true,\\n _ => false,\\n },\\n\\n _ => false,\\n }\\n }\\n } else {\\n is_kwd_op\\n || match *node.right {\\n Expr::Unary(..) | Expr::Update(UpdateExpr { prefix: true, .. }) => true,\\n _ => false,\\n }\\n };\\n if need_post_space {\\n space!(self);\\n } else {\\n formatting_space!(self);\\n }\\n emit!(self, node.right);\\n\\n Ok(())\\n }\\n\\n #[emitter]\\n fn emit_bin_expr(&mut self, node: &BinExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n {\\n let mut left = Some(node);\\n let mut lefts = vec![];\\n while let Some(l) = left {\\n lefts.push(l);\\n\\n match &*l.left {\\n Expr::Bin(b) => {\\n left = Some(b);\\n }\\n _ => break,\\n }\\n }\\n\\n let len = lefts.len();\\n\\n for (i, left) in lefts.into_iter().rev().enumerate() {\\n if i == 0 {\\n emit!(left.left);\\n }\\n // Check if it\\'s last\\n if i + 1 != len {\\n self.emit_bin_expr_trailing(left)?;\\n }\\n }\\n }\\n\\n self.emit_bin_expr_trailing(node)?;\\n }\\n\\n #[emitter]\\n fn emit_decorator(&mut self, node: &Decorator) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n punct!(\"@\");\\n emit!(node.expr);\\n self.wr.write_line()?;\\n }\\n\\n #[emitter]\\n fn emit_class_expr(&mut self, node: &ClassExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n for dec in &node.class.decorators {\\n emit!(dec);\\n }\\n\\n keyword!(\"class\");\\n\\n if let Some(ref i) = node.ident {\\n space!();\\n emit!(i);\\n emit!(node.class.type_params);\\n }\\n\\n self.emit_class_trailing(&node.class)?;\\n }\\n\\n #[emitter]\\n fn emit_class_trailing(&mut self, node: &Class) -> Result {\\n if node.super_class.is_some() {\\n space!();\\n keyword!(\"extends\");\\n\\n {\\n let starts_with_alpha_num =\\n node.super_class.as_ref().unwrap().starts_with_alpha_num();\\n\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!()\\n }\\n }\\n emit!(node.super_class);\\n }\\n\\n formatting_space!();\\n punct!(\"{\");\\n self.emit_list(node.span, Some(&node.body), ListFormat::ClassMembers)?;\\n punct!(\"}\");\\n }\\n\\n #[emitter]\\n fn emit_class_memeber(&mut self, node: &ClassMember) -> Result {\\n match *node {\\n ClassMember::Constructor(ref n) => emit!(n),\\n ClassMember::ClassProp(ref n) => emit!(n),\\n ClassMember::Method(ref n) => emit!(n),\\n ClassMember::PrivateMethod(ref n) => emit!(n),\\n ClassMember::PrivateProp(ref n) => emit!(n),\\n ClassMember::TsIndexSignature(ref n) => emit!(n),\\n ClassMember::Empty(ref n) => emit!(n),\\n ClassMember::StaticBlock(ref n) => emit!(n),\\n }\\n }\\n\\n #[emitter]\\n fn emit_private_method(&mut self, n: &PrivateMethod) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n if n.is_static {\\n keyword!(\"static\");\\n space!();\\n }\\n match n.kind {\\n MethodKind::Method => {\\n if n.function.is_async {\\n keyword!(\"async\");\\n }\\n space!();\\n if n.function.is_generator {\\n punct!(\"*\");\\n }\\n\\n emit!(n.key);\\n }\\n MethodKind::Getter => {\\n keyword!(\"get\");\\n space!();\\n\\n emit!(n.key);\\n }\\n MethodKind::Setter => {\\n keyword!(\"set\");\\n space!();\\n\\n emit!(n.key);\\n }\\n }\\n\\n self.emit_fn_trailing(&n.function)?;\\n }\\n\\n #[emitter]\\n fn emit_bool(&mut self, n: &Bool) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n if n.value {\\n keyword!(n.span, \"true\")\\n } else {\\n keyword!(n.span, \"false\")\\n }\\n }\\n\\n #[emitter]\\n fn emit_class_method(&mut self, n: &ClassMethod) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n self.emit_accesibility(n.accessibility)?;\\n\\n if n.is_static {\\n keyword!(\"static\");\\n\\n let starts_with_alpha_num = match n.kind {\\n MethodKind::Method => {\\n if n.function.is_async {\\n true\\n } else if n.function.is_generator {\\n false\\n } else {\\n n.key.starts_with_alpha_num()\\n }\\n }\\n MethodKind::Getter => true,\\n MethodKind::Setter => true,\\n };\\n\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n }\\n match n.kind {\\n MethodKind::Method => {\\n if n.function.is_async {\\n keyword!(\"async\");\\n space!();\\n }\\n if n.function.is_generator {\\n punct!(\"*\");\\n }\\n\\n emit!(n.key);\\n }\\n MethodKind::Getter => {\\n keyword!(\"get\");\\n\\n if n.key.starts_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!()\\n }\\n\\n emit!(n.key);\\n }\\n MethodKind::Setter => {\\n keyword!(\"set\");\\n\\n if n.key.starts_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!()\\n }\\n\\n emit!(n.key);\\n }\\n }\\n\\n if let Some(type_params) = &n.function.type_params {\\n emit!(type_params);\\n }\\n\\n punct!(\"(\");\\n self.emit_list(\\n n.function.span,\\n Some(&n.function.params),\\n ListFormat::CommaListElements,\\n )?;\\n punct!(\")\");\\n\\n if let Some(ty) = &n.function.return_type {\\n punct!(\":\");\\n formatting_space!();\\n emit!(ty);\\n }\\n\\n if let Some(body) = &n.function.body {\\n formatting_space!();\\n emit!(body);\\n } else {\\n formatting_semi!()\\n }\\n }\\n\\n #[emitter]\\n fn emit_private_prop(&mut self, n: &PrivateProp) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n self.emit_list(n.span, Some(&n.decorators), ListFormat::Decorators)?;\\n\\n self.emit_accesibility(n.accessibility)?;\\n\\n if n.is_static {\\n keyword!(\"static\");\\n space!();\\n }\\n\\n if n.readonly {\\n keyword!(\"readonly\");\\n space!();\\n }\\n\\n emit!(n.key);\\n if let Some(type_ann) = &n.type_ann {\\n punct!(\":\");\\n space!();\\n emit!(type_ann);\\n }\\n\\n if let Some(value) = &n.value {\\n formatting_space!();\\n punct!(\"=\");\\n formatting_space!();\\n\\n if value.is_seq() {\\n punct!(\"(\");\\n emit!(value);\\n punct!(\")\");\\n } else {\\n emit!(value);\\n }\\n }\\n\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_class_prop(&mut self, n: &ClassProp) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n if n.accessibility != Some(Accessibility::Public) {\\n self.emit_accesibility(n.accessibility)?;\\n }\\n\\n if n.is_static {\\n keyword!(\"static\");\\n space!();\\n }\\n\\n if n.readonly {\\n keyword!(\"readonly\");\\n space!()\\n }\\n\\n if n.computed {\\n punct!(\"[\");\\n emit!(n.key);\\n punct!(\"]\");\\n } else {\\n emit!(n.key);\\n }\\n\\n if let Some(ty) = &n.type_ann {\\n punct!(\":\");\\n space!();\\n emit!(ty);\\n }\\n\\n if let Some(v) = &n.value {\\n formatting_space!();\\n punct!(\"=\");\\n formatting_space!();\\n\\n if v.is_seq() {\\n punct!(\"(\");\\n emit!(v);\\n punct!(\")\");\\n } else {\\n emit!(v);\\n }\\n }\\n\\n formatting_semi!();\\n }\\n\\n fn emit_accesibility(&mut self, n: Option) -> Result {\\n if let Some(a) = n {\\n match a {\\n Accessibility::Public => keyword!(self, \"public\"),\\n Accessibility::Protected => keyword!(self, \"protected\"),\\n Accessibility::Private => keyword!(self, \"private\"),\\n }\\n space!(self);\\n }\\n\\n Ok(())\\n }\\n\\n #[emitter]\\n fn emit_class_constructor(&mut self, n: &Constructor) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n self.emit_accesibility(n.accessibility)?;\\n\\n keyword!(\"constructor\");\\n punct!(\"(\");\\n self.emit_list(n.span(), Some(&n.params), ListFormat::Parameters)?;\\n punct!(\")\");\\n\\n if let Some(body) = &n.body {\\n emit!(body);\\n } else {\\n formatting_semi!();\\n }\\n }\\n\\n #[emitter]\\n fn emit_static_block(&mut self, n: &StaticBlock) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n keyword!(\"static\");\\n emit!(n.body);\\n }\\n\\n #[emitter]\\n fn emit_prop_name(&mut self, node: &PropName) -> Result {\\n match *node {\\n PropName::Ident(ref n) => emit!(n),\\n PropName::Str(ref n) => emit!(n),\\n PropName::Num(ref n) => emit!(n),\\n PropName::BigInt(ref n) => emit!(n),\\n PropName::Computed(ref n) => emit!(n),\\n }\\n }\\n\\n #[emitter]\\n fn emit_computed_prop_name(&mut self, node: &ComputedPropName) -> Result {\\n punct!(\"[\");\\n emit!(node.expr);\\n punct!(\"]\");\\n }\\n\\n #[emitter]\\n fn emit_cond_expr(&mut self, node: &CondExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.test);\\n formatting_space!();\\n punct!(\"?\");\\n formatting_space!();\\n emit!(node.cons);\\n formatting_space!();\\n punct!(\":\");\\n formatting_space!();\\n emit!(node.alt);\\n }\\n\\n #[emitter]\\n fn emit_fn_expr(&mut self, n: &FnExpr) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n if n.function.is_async {\\n keyword!(\"async\");\\n space!();\\n keyword!(\"function\");\\n } else {\\n let span = if n.span().is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span().lo, n.span().lo + BytePos(8), Default::default())\\n };\\n keyword!(span, \"function\");\\n }\\n\\n if n.function.is_generator {\\n punct!(\"*\");\\n }\\n if let Some(ref i) = n.ident {\\n space!();\\n emit!(i);\\n }\\n\\n self.emit_fn_trailing(&n.function)?;\\n }\\n\\n /// prints `(b){}` from `function a(b){}`\\n #[emitter]\\n fn emit_fn_trailing(&mut self, node: &Function) -> Result {\\n if let Some(type_params) = &node.type_params {\\n emit!(type_params);\\n }\\n\\n punct!(\"(\");\\n self.emit_list(node.span, Some(&node.params), ListFormat::CommaListElements)?;\\n punct!(\")\");\\n\\n if let Some(ty) = &node.return_type {\\n punct!(\":\");\\n formatting_space!();\\n emit!(ty);\\n }\\n\\n if let Some(body) = &node.body {\\n formatting_space!();\\n emit!(body);\\n } else {\\n formatting_semi!()\\n }\\n }\\n\\n #[emitter]\\n fn emit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) -> Result {\\n match *node {\\n BlockStmtOrExpr::BlockStmt(ref block_stmt) => emit!(block_stmt),\\n BlockStmtOrExpr::Expr(ref expr) => {\\n self.wr.increase_indent()?;\\n emit!(expr);\\n self.wr.decrease_indent()?;\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n }\\n }\\n }\\n\\n #[emitter]\\n fn emit_this_expr(&mut self, node: &ThisExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(node.span, \"this\");\\n }\\n\\n #[emitter]\\n fn emit_tpl_lit(&mut self, node: &Tpl) -> Result {\\n debug_assert!(node.quasis.len() == node.exprs.len() + 1);\\n\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n punct!(\"`\");\\n let i = 0;\\n\\n for i in 0..(node.quasis.len() + node.exprs.len()) {\\n if i % 2 == 0 {\\n emit!(node.quasis[i / 2]);\\n } else {\\n punct!(\"${\");\\n emit!(node.exprs[i / 2]);\\n punct!(\"}\");\\n }\\n }\\n\\n punct!(\"`\");\\n }\\n\\n #[emitter]\\n fn emit_tagged_tpl_lit(&mut self, node: &TaggedTpl) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.tag);\\n emit!(node.type_params);\\n emit!(node.tpl);\\n }\\n\\n #[emitter]\\n fn emit_quasi(&mut self, node: &TplElement) -> Result {\\n let is_synthesized = match node.raw.kind {\\n StrKind::Synthesized => true,\\n _ => false,\\n };\\n\\n self.wr.write_str_lit(\\n node.span,\\n &unescape_tpl_lit(&node.raw.value, is_synthesized),\\n )?;\\n return Ok(());\\n }\\n\\n #[emitter]\\n fn emit_unary_expr(&mut self, n: &UnaryExpr) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n let need_formatting_space = match n.op {\\n op!(\"typeof\") | op!(\"void\") | op!(\"delete\") => {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(\\n n.span.lo,\\n n.span.lo + BytePos(n.op.as_str().len() as _),\\n Default::default(),\\n )\\n };\\n keyword!(span, n.op.as_str());\\n\\n true\\n }\\n op!(unary, \"+\") | op!(unary, \"-\") | op!(\"!\") | op!(\"~\") => {\\n punct!(n.op.as_str());\\n false\\n }\\n };\\n\\n if should_emit_whitespace_before_operand(n) {\\n space!();\\n } else if need_formatting_space {\\n formatting_space!();\\n }\\n\\n emit!(n.arg);\\n }\\n\\n #[emitter]\\n fn emit_update_expr(&mut self, node: &UpdateExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n if node.prefix {\\n operator!(node.op.as_str());\\n //TODO: Check if we should use should_emit_whitespace_before_operand\\n emit!(node.arg);\\n } else {\\n emit!(node.arg);\\n operator!(node.op.as_str());\\n }\\n }\\n\\n #[emitter]\\n fn emit_yield_expr(&mut self, node: &YieldExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"yield\");\\n if node.delegate {\\n operator!(\"*\");\\n }\\n\\n if let Some(ref arg) = node.arg {\\n if !node.delegate && arg.starts_with_alpha_num() {\\n space!()\\n } else {\\n formatting_space!()\\n }\\n emit!(node.arg);\\n }\\n }\\n\\n fn emit_expr_or_spreads(\\n &mut self,\\n parent_node: Span,\\n nodes: &[ExprOrSpread],\\n format: ListFormat,\\n ) -> Result {\\n self.emit_list(parent_node, Some(nodes), format)\\n }\\n\\n #[emitter]\\n fn emit_expr_or_spread(&mut self, node: &ExprOrSpread) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n if node.spread.is_some() {\\n punct!(\"...\");\\n }\\n\\n emit!(node.expr);\\n }\\n\\n #[emitter]\\n fn emit_await_expr(&mut self, n: &AwaitExpr) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(5), Default::default())\\n };\\n keyword!(span, \"await\");\\n }\\n\\n space!();\\n\\n emit!(&n.arg);\\n }\\n\\n #[emitter]\\n fn emit_array_lit(&mut self, node: &ArrayLit) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.lo, node.span.lo + BytePos(1), Default::default())\\n };\\n punct!(span, \"[\");\\n }\\n self.emit_list(\\n node.span(),\\n Some(&node.elems),\\n ListFormat::ArrayLiteralExpressionElements,\\n )?;\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.hi - BytePos(1), node.span.hi, Default::default())\\n };\\n punct!(span, \"]\");\\n }\\n }\\n\\n #[emitter]\\n fn emit_object_lit(&mut self, node: &ObjectLit) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.lo, node.span.lo + BytePos(1), Default::default())\\n };\\n punct!(span, \"{\");\\n }\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n self.emit_list(\\n node.span(),\\n Some(&node.props),\\n ListFormat::ObjectLiteralExpressionProperties | ListFormat::CanSkipTrailingComma,\\n )?;\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.hi - BytePos(1), node.span.hi, Default::default())\\n };\\n punct!(span, \"}\");\\n }\\n }\\n\\n #[emitter]\\n fn emit_prop(&mut self, node: &Prop) -> Result {\\n match *node {\\n Prop::Shorthand(ref n) => emit!(n),\\n Prop::KeyValue(ref n) => emit!(n),\\n Prop::Assign(ref n) => emit!(n),\\n Prop::Getter(ref n) => emit!(n),\\n Prop::Setter(ref n) => emit!(n),\\n Prop::Method(ref n) => emit!(n),\\n }\\n }\\n\\n #[emitter]\\n fn emit_kv_prop(&mut self, node: &KeyValueProp) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.key);\\n punct!(\":\");\\n formatting_space!();\\n emit!(node.value);\\n }\\n\\n #[emitter]\\n fn emit_assign_prop(&mut self, node: &AssignProp) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.key);\\n punct!(\"=\");\\n emit!(node.value);\\n }\\n\\n #[emitter]\\n fn emit_getter_prop(&mut self, node: &GetterProp) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"get\");\\n\\n let starts_with_alpha_num = match node.key {\\n PropName::Str(_) | PropName::Computed(_) => false,\\n _ => true,\\n };\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n emit!(node.key);\\n formatting_space!();\\n punct!(\"(\");\\n punct!(\")\");\\n formatting_space!();\\n emit!(node.body);\\n }\\n\\n #[emitter]\\n fn emit_setter_prop(&mut self, node: &SetterProp) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"set\");\\n\\n let starts_with_alpha_num = match node.key {\\n PropName::Str(_) | PropName::Computed(_) => false,\\n _ => true,\\n };\\n\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n\\n emit!(node.key);\\n formatting_space!();\\n\\n punct!(\"(\");\\n emit!(node.param);\\n punct!(\")\");\\n\\n emit!(node.body);\\n }\\n\\n #[emitter]\\n fn emit_method_prop(&mut self, node: &MethodProp) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n if node.function.is_async {\\n keyword!(\"async\");\\n space!();\\n }\\n\\n if node.function.is_generator {\\n punct!(\"*\");\\n }\\n\\n emit!(node.key);\\n formatting_space!();\\n // TODO\\n self.emit_fn_trailing(&node.function)?;\\n }\\n\\n #[emitter]\\n fn emit_paren_expr(&mut self, node: &ParenExpr) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n punct!(\"(\");\\n emit!(node.expr);\\n punct!(\")\");\\n }\\n\\n #[emitter]\\n fn emit_private_name(&mut self, n: &PrivateName) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(1), Default::default())\\n };\\n punct!(span, \"#\");\\n }\\n emit!(n.id)\\n }\\n\\n #[emitter]\\n fn emit_binding_ident(&mut self, ident: &BindingIdent) -> Result {\\n emit!(ident.id);\\n\\n if let Some(ty) = &ident.type_ann {\\n punct!(\":\");\\n formatting_space!();\\n emit!(ty);\\n }\\n\\n // Call emitList directly since it could be an array of\\n // TypeParameterDeclarations _or_ type arguments\\n\\n // emitList(node, node.typeArguments, ListFormat::TypeParameters);\\n }\\n\\n #[emitter]\\n fn emit_ident(&mut self, ident: &Ident) -> Result {\\n // TODO: Use write_symbol when ident is a symbol.\\n self.emit_leading_comments_of_span(ident.span, false)?;\\n\\n // TODO: span\\n self.wr\\n .write_symbol(ident.span, &handle_invalid_unicodes(&ident.sym))?;\\n if ident.optional {\\n punct!(\"?\");\\n }\\n\\n // Call emitList directly since it could be an array of\\n // TypeParameterDeclarations _or_ type arguments\\n\\n // emitList(node, node.typeArguments, ListFormat::TypeParameters);\\n }\\n\\n fn emit_list(\\n &mut self,\\n parent_node: Span,\\n children: Option<&[N]>,\\n format: ListFormat,\\n ) -> Result {\\n self.emit_list5(\\n parent_node,\\n children,\\n format,\\n 0,\\n children.map(|c| c.len()).unwrap_or(0),\\n )\\n }\\n\\n #[allow(clippy::cognitive_complexity)]\\n fn emit_list5(\\n &mut self,\\n parent_node: Span,\\n children: Option<&[N]>,\\n format: ListFormat,\\n start: usize,\\n count: usize,\\n ) -> Result {\\n if children.is_none() && format.contains(ListFormat::OptionalIfUndefined) {\\n return Ok(());\\n }\\n\\n let is_empty = children.is_none() || start > children.unwrap().len() || count == 0;\\n if is_empty && format.contains(ListFormat::OptionalIfEmpty) {\\n return Ok(());\\n }\\n\\n if format.contains(ListFormat::BracketsMask) {\\n self.wr.write_punct(None, format.opening_bracket())?;\\n\\n if is_empty {\\n self.emit_trailing_comments_of_pos(\\n {\\n // TODO: children.lo()\\n\\n parent_node.lo()\\n },\\n true,\\n false,\\n )?;\\n }\\n }\\n\\n // self.handlers.onBeforeEmitNodeArray(children);\\n\\n if is_empty {\\n // Write a line terminator if the parent node was multi-line\\n\\n if format.contains(ListFormat::MultiLine) {\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n } else if format.contains(ListFormat::SpaceBetweenBraces)\\n && !(format.contains(ListFormat::NoSpaceIfEmpty))\\n && !self.cfg.minify\\n {\\n self.wr.write_space()?;\\n }\\n } else {\\n let children = children.unwrap();\\n\\n // Write the opening line terminator or leading whitespace.\\n let may_emit_intervening_comments =\\n !format.intersects(ListFormat::NoInterveningComments);\\n let mut should_emit_intervening_comments = may_emit_intervening_comments;\\n if self\\n .cm\\n .should_write_leading_line_terminator(parent_node, children, format)\\n {\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n should_emit_intervening_comments = false;\\n } else if format.contains(ListFormat::SpaceBetweenBraces) && !self.cfg.minify {\\n self.wr.write_space()?;\\n }\\n\\n // Increase the indent, if requested.\\n if format.contains(ListFormat::Indented) && !self.cfg.minify {\\n self.wr.increase_indent()?;\\n }\\n\\n // Emit each child.\\n let mut previous_sibling: Option = None;\\n let mut should_decrease_indent_after_emit = false;\\n for i in 0..count {\\n let child = &children[start + i];\\n\\n // Write the delimiter if this is not the first node.\\n if let Some(previous_sibling) = previous_sibling {\\n // i.e\\n // function commentedParameters(\\n // /* Parameter a */\\n // a\\n // /* End of parameter a */\\n // -> this comment isn\\'t considered to be trailing comment of parameter \"a\" due\\n // to newline ,\\n if format.contains(ListFormat::DelimitersMask)\\n && previous_sibling.span().hi() != parent_node.hi()\\n {\\n self.emit_leading_comments(previous_sibling.span().hi(), true)?;\\n }\\n\\n self.write_delim(format)?;\\n\\n // Write either a line terminator or whitespace to separate the elements.\\n\\n if self.cm.should_write_separating_line_terminator(\\n Some(previous_sibling),\\n Some(child),\\n format,\\n ) {\\n // If a synthesized node in a single-line list starts on a new\\n // line, we should increase the indent.\\n if (format & (ListFormat::LinesMask | ListFormat::Indented))\\n == ListFormat::SingleLine\\n && !self.cfg.minify\\n {\\n self.wr.increase_indent()?;\\n should_decrease_indent_after_emit = true;\\n }\\n\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n should_emit_intervening_comments = false;\\n } else if format.contains(ListFormat::SpaceBetweenSiblings) {\\n formatting_space!(self);\\n }\\n }\\n\\n child.emit_with(self)?;\\n\\n // Emit this child.\\n if should_emit_intervening_comments {\\n let comment_range = child.comment_range();\\n self.emit_trailing_comments_of_pos(comment_range.hi(), false, true)?;\\n } else {\\n should_emit_intervening_comments = may_emit_intervening_comments;\\n }\\n\\n if should_decrease_indent_after_emit {\\n self.wr.decrease_indent()?;\\n should_decrease_indent_after_emit = false;\\n }\\n\\n previous_sibling = Some(child.span());\\n }\\n\\n // Write a trailing comma, if requested.\\n let has_trailing_comma = format.contains(ListFormat::AllowTrailingComma) && {\\n if parent_node.is_dummy() {\\n false\\n } else {\\n match self.cm.span_to_snippet(parent_node) {\\n Ok(snippet) => {\\n if snippet.len() < 3 {\\n false\\n } else {\\n snippet[..snippet.len() - 1].trim().ends_with(\\',\\')\\n }\\n }\\n _ => false,\\n }\\n }\\n };\\n\\n if has_trailing_comma && format.contains(ListFormat::CommaDelimited) {\\n if !self.cfg.minify || !format.contains(ListFormat::CanSkipTrailingComma) {\\n punct!(self, \",\");\\n formatting_space!(self);\\n }\\n }\\n\\n {\\n // Emit any trailing comment of the last element in the list\\n // i.e\\n // var array = [...\\n // 2\\n // /* end of element 2 */\\n // ];\\n\\n let emit_trailing_comments = {\\n // TODO:\\n //\\n // !(getEmitFlags(previousSibling).contains(EmitFlags::NoTrailingComments))\\n\\n true\\n };\\n\\n if let Some(previous_sibling) = previous_sibling {\\n if format.contains(ListFormat::DelimitersMask)\\n && previous_sibling.span().hi() != parent_node.hi()\\n && emit_trailing_comments\\n {\\n self.emit_leading_comments(previous_sibling.span().hi(), true)?;\\n }\\n }\\n }\\n\\n // Decrease the indent, if requested.\\n if format.contains(ListFormat::Indented) && !self.cfg.minify {\\n self.wr.decrease_indent()?;\\n }\\n\\n // Write the closing line terminator or closing whitespace.\\n if self\\n .cm\\n .should_write_closing_line_terminator(parent_node, children, format)\\n {\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n } else if format.contains(ListFormat::SpaceBetweenBraces) && !self.cfg.minify {\\n self.wr.write_space()?;\\n }\\n }\\n\\n // self.handlers.onAfterEmitNodeArray(children);\\n\\n if format.contains(ListFormat::BracketsMask) {\\n if is_empty {\\n self.emit_leading_comments(\\n {\\n //TODO: children.hi()\\n\\n parent_node.hi()\\n },\\n true,\\n )?; // Emit leading comments within empty lists\\n }\\n self.wr.write_punct(None, format.closing_bracket())?;\\n }\\n\\n Ok(())\\n }\\n}\\n\\n/// Patterns\\nimpl<\\'a, W> Emitter<\\'a, W>\\nwhere\\n W: WriteJs,\\n{\\n #[emitter]\\n fn emit_param(&mut self, node: &Param) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n self.emit_list(node.span, Some(&node.decorators), ListFormat::Decorators)?;\\n\\n emit!(node.pat);\\n }\\n\\n #[emitter]\\n fn emit_pat(&mut self, node: &Pat) -> Result {\\n match node {\\n Pat::Array(ref n) => emit!(n),\\n Pat::Assign(ref n) => emit!(n),\\n Pat::Expr(ref n) => emit!(n),\\n Pat::Ident(ref n) => emit!(n),\\n Pat::Object(ref n) => emit!(n),\\n Pat::Rest(ref n) => emit!(n),\\n Pat::Invalid(n) => emit!(n),\\n }\\n\\n self.emit_trailing_comments_of_pos(node.span().hi, true, true)?;\\n }\\n\\n #[emitter]\\n fn emit_rest_pat(&mut self, node: &RestPat) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n punct!(\"...\");\\n emit!(node.arg);\\n\\n if let Some(type_ann) = &node.type_ann {\\n punct!(\":\");\\n formatting_space!();\\n emit!(type_ann);\\n }\\n }\\n\\n #[emitter]\\n fn emit_prop_or_spread(&mut self, node: &PropOrSpread) -> Result {\\n match *node {\\n PropOrSpread::Prop(ref n) => emit!(n),\\n PropOrSpread::Spread(ref n) => emit!(n),\\n }\\n }\\n\\n #[emitter]\\n fn emit_spread_element(&mut self, node: &SpreadElement) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n punct!(\"...\");\\n emit!(node.expr)\\n }\\n\\n #[emitter]\\n fn emit_pat_or_expr(&mut self, node: &PatOrExpr) -> Result {\\n match *node {\\n PatOrExpr::Expr(ref n) => emit!(n),\\n PatOrExpr::Pat(ref n) => emit!(n),\\n }\\n }\\n\\n #[emitter]\\n fn emit_array_pat(&mut self, node: &ArrayPat) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n punct!(\"[\");\\n self.emit_list(\\n node.span(),\\n Some(&node.elems),\\n ListFormat::ArrayBindingPatternElements,\\n )?;\\n punct!(\"]\");\\n if node.optional {\\n punct!(\"?\");\\n }\\n\\n if let Some(type_ann) = &node.type_ann {\\n punct!(\":\");\\n space!();\\n emit!(type_ann);\\n }\\n }\\n\\n #[emitter]\\n fn emit_assign_pat(&mut self, node: &AssignPat) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.left);\\n formatting_space!();\\n punct!(\"=\");\\n formatting_space!();\\n emit!(node.right);\\n }\\n\\n #[emitter]\\n fn emit_object_pat(&mut self, node: &ObjectPat) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n let is_last_rest = match node.props.last() {\\n Some(ObjectPatProp::Rest(..)) => true,\\n _ => false,\\n };\\n let format = if is_last_rest {\\n ListFormat::ObjectBindingPatternElements ^ ListFormat::AllowTrailingComma\\n } else {\\n ListFormat::ObjectBindingPatternElements\\n };\\n\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.lo, node.span.lo + BytePos(1), Default::default())\\n };\\n punct!(span, \"{\");\\n }\\n self.emit_list(\\n node.span(),\\n Some(&node.props),\\n format | ListFormat::CanSkipTrailingComma,\\n )?;\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.hi - BytePos(1), node.span.hi, Default::default())\\n };\\n punct!(span, \"}\");\\n }\\n if node.optional {\\n punct!(\"?\");\\n }\\n\\n if let Some(type_ann) = &node.type_ann {\\n punct!(\":\");\\n space!();\\n emit!(type_ann);\\n }\\n }\\n\\n #[emitter]\\n fn emit_object_pat_prop(&mut self, node: &ObjectPatProp) -> Result {\\n match *node {\\n ObjectPatProp::KeyValue(ref node) => emit!(node),\\n ObjectPatProp::Assign(ref node) => emit!(node),\\n ObjectPatProp::Rest(ref node) => emit!(node),\\n }\\n }\\n\\n #[emitter]\\n fn emit_object_kv_pat(&mut self, node: &KeyValuePatProp) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.key);\\n punct!(\":\");\\n formatting_space!();\\n emit!(node.value);\\n formatting_space!();\\n }\\n\\n #[emitter]\\n fn emit_object_assign_pat(&mut self, node: &AssignPatProp) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n emit!(node.key);\\n formatting_space!();\\n if let Some(ref value) = node.value {\\n punct!(\"=\");\\n emit!(node.value);\\n formatting_space!();\\n }\\n }\\n\\n #[emitter]\\n fn emit_var_decl_or_pat(&mut self, node: &VarDeclOrPat) -> Result {\\n match *node {\\n VarDeclOrPat::Pat(ref n) => emit!(n),\\n VarDeclOrPat::VarDecl(ref n) => emit!(n),\\n }\\n }\\n}\\n\\n/// Statements\\nimpl<\\'a, W> Emitter<\\'a, W>\\nwhere\\n W: WriteJs,\\n{\\n #[emitter]\\n fn emit_stmt(&mut self, node: &Stmt) -> Result {\\n match *node {\\n Stmt::Expr(ref e) => emit!(e),\\n Stmt::Block(ref e) => {\\n emit!(e);\\n return Ok(());\\n }\\n Stmt::Empty(ref e) => emit!(e),\\n Stmt::Debugger(ref e) => emit!(e),\\n Stmt::With(ref e) => emit!(e),\\n Stmt::Return(ref e) => emit!(e),\\n Stmt::Labeled(ref e) => emit!(e),\\n Stmt::Break(ref e) => emit!(e),\\n Stmt::Continue(ref e) => emit!(e),\\n Stmt::If(ref e) => emit!(e),\\n Stmt::Switch(ref e) => emit!(e),\\n Stmt::Throw(ref e) => emit!(e),\\n Stmt::Try(ref e) => emit!(e),\\n Stmt::While(ref e) => emit!(e),\\n Stmt::DoWhile(ref e) => emit!(e),\\n Stmt::For(ref e) => emit!(e),\\n Stmt::ForIn(ref e) => emit!(e),\\n Stmt::ForOf(ref e) => emit!(e),\\n Stmt::Decl(ref e) => emit!(e),\\n }\\n self.emit_trailing_comments_of_pos(node.span().hi(), true, true)?;\\n\\n if !self.cfg.minify {\\n self.wr.write_line()?;\\n }\\n }\\n\\n #[emitter]\\n fn emit_expr_stmt(&mut self, e: &ExprStmt) -> Result {\\n emit!(e.expr);\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_block_stmt(&mut self, node: &BlockStmt) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.lo, node.span.lo + BytePos(1), Default::default())\\n };\\n punct!(span, \"{\");\\n }\\n self.emit_list(\\n node.span(),\\n Some(&node.stmts),\\n ListFormat::MultiLineBlockStatements,\\n )?;\\n\\n self.emit_leading_comments_of_span(node.span(), true)?;\\n\\n {\\n let span = if node.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(node.span.hi - BytePos(1), node.span.hi, Default::default())\\n };\\n punct!(span, \"}\");\\n }\\n }\\n\\n #[emitter]\\n fn emit_empty_stmt(&mut self, node: &EmptyStmt) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n semi!();\\n }\\n\\n #[emitter]\\n fn emit_debugger_stmt(&mut self, node: &DebuggerStmt) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(node.span, \"debugger\");\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_with_stmt(&mut self, node: &WithStmt) -> Result {\\n keyword!(\"with\");\\n formatting_space!();\\n\\n punct!(\"(\");\\n emit!(node.obj);\\n punct!(\")\");\\n\\n emit!(node.body);\\n }\\n\\n #[emitter]\\n fn emit_return_stmt(&mut self, n: &ReturnStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span, false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(6), Default::default())\\n };\\n keyword!(span, \"return\");\\n }\\n\\n if let Some(ref arg) = n.arg {\\n let need_paren = !n.arg.span().is_dummy()\\n && if let Some(cmt) = self.comments {\\n let lo = n.arg.span().lo();\\n\\n // see #415\\n cmt.has_leading(lo)\\n } else {\\n false\\n };\\n if need_paren {\\n punct!(\"(\");\\n } else {\\n if arg.starts_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n }\\n\\n emit!(arg);\\n if need_paren {\\n punct!(\")\");\\n }\\n }\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_labeled_stmt(&mut self, node: &LabeledStmt) -> Result {\\n emit!(node.label);\\n\\n // TODO: Comment\\n punct!(\":\");\\n formatting_space!();\\n\\n emit!(node.body);\\n }\\n\\n #[emitter]\\n fn emit_break_stmt(&mut self, n: &BreakStmt) -> Result {\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(5), Default::default())\\n };\\n keyword!(span, \"break\");\\n }\\n\\n if let Some(ref label) = n.label {\\n space!();\\n emit!(label);\\n }\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_continue_stmt(&mut self, n: &ContinueStmt) -> Result {\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(8), Default::default())\\n };\\n keyword!(span, \"continue\");\\n }\\n if let Some(ref label) = n.label {\\n space!();\\n emit!(label);\\n }\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_if_stmt(&mut self, n: &IfStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(2), Default::default())\\n };\\n keyword!(span, \"if\");\\n }\\n\\n formatting_space!();\\n punct!(\"(\");\\n emit!(n.test);\\n punct!(\")\");\\n formatting_space!();\\n\\n let is_cons_block = match *n.cons {\\n Stmt::Block(..) => true,\\n _ => false,\\n };\\n\\n emit!(n.cons);\\n\\n if let Some(ref alt) = n.alt {\\n if is_cons_block {\\n formatting_space!();\\n }\\n keyword!(\"else\");\\n if alt.starts_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n emit!(alt);\\n }\\n }\\n\\n #[emitter]\\n fn emit_switch_stmt(&mut self, n: &SwitchStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(6), Default::default())\\n };\\n keyword!(span, \"switch\");\\n }\\n\\n punct!(\"(\");\\n emit!(n.discriminant);\\n punct!(\")\");\\n\\n punct!(\"{\");\\n self.emit_list(n.span(), Some(&n.cases), ListFormat::CaseBlockClauses)?;\\n punct!(\"}\");\\n }\\n\\n #[emitter]\\n fn emit_catch_clause(&mut self, n: &CatchClause) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(5), Default::default())\\n };\\n keyword!(span, \"catch\");\\n }\\n formatting_space!();\\n\\n if let Some(param) = &n.param {\\n punct!(\"(\");\\n emit!(param);\\n punct!(\")\");\\n }\\n\\n formatting_space!();\\n\\n emit!(n.body);\\n }\\n\\n #[emitter]\\n fn emit_switch_case(&mut self, n: &SwitchCase) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n if let Some(ref test) = n.test {\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(4), Default::default())\\n };\\n keyword!(span, \"case\");\\n }\\n\\n let starts_with_alpha_num = test.starts_with_alpha_num();\\n\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n\\n emit!(test);\\n } else {\\n keyword!(\"default\");\\n }\\n\\n let emit_as_single_stmt = n.cons.len() == 1 && {\\n // treat synthesized nodes as located on the same line for emit purposes\\n n.is_synthesized()\\n || n.cons[0].is_synthesized()\\n || self\\n .cm\\n .is_on_same_line(n.span().lo(), n.cons[0].span().lo())\\n };\\n\\n let mut format = ListFormat::CaseOrDefaultClauseStatements;\\n if emit_as_single_stmt {\\n punct!(\":\");\\n space!();\\n format &= !(ListFormat::MultiLine | ListFormat::Indented);\\n } else {\\n punct!(\":\");\\n }\\n self.emit_list(n.span(), Some(&n.cons), format)?;\\n }\\n\\n #[emitter]\\n fn emit_throw_stmt(&mut self, n: &ThrowStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(5), Default::default())\\n };\\n keyword!(span, \"throw\");\\n }\\n\\n {\\n if n.arg.starts_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n emit!(n.arg);\\n }\\n formatting_semi!();\\n }\\n\\n #[emitter]\\n fn emit_try_stmt(&mut self, n: &TryStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(3), Default::default())\\n };\\n keyword!(span, \"try\");\\n }\\n formatting_space!();\\n emit!(n.block);\\n\\n if let Some(ref catch) = n.handler {\\n formatting_space!();\\n emit!(catch);\\n }\\n\\n if let Some(ref finally) = n.finalizer {\\n formatting_space!();\\n keyword!(\"finally\");\\n // space!();\\n emit!(finally);\\n }\\n }\\n\\n #[emitter]\\n fn emit_while_stmt(&mut self, node: &WhileStmt) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"while\");\\n\\n punct!(\"(\");\\n emit!(node.test);\\n punct!(\")\");\\n\\n emit!(node.body);\\n }\\n\\n #[emitter]\\n fn emit_do_while_stmt(&mut self, node: &DoWhileStmt) -> Result {\\n self.emit_leading_comments_of_span(node.span(), false)?;\\n\\n keyword!(\"do\");\\n if node.body.starts_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!()\\n }\\n emit!(node.body);\\n\\n keyword!(\"while\");\\n\\n formatting_space!();\\n\\n punct!(\"(\");\\n emit!(node.test);\\n punct!(\")\");\\n }\\n\\n #[emitter]\\n fn emit_for_stmt(&mut self, n: &ForStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(3), Default::default())\\n };\\n keyword!(span, \"for\");\\n }\\n punct!(\"(\");\\n opt!(n.init);\\n semi!();\\n opt_leading_space!(n.test);\\n semi!();\\n opt_leading_space!(n.update);\\n punct!(\")\");\\n\\n emit!(n.body);\\n }\\n\\n #[emitter]\\n fn emit_for_in_stmt(&mut self, n: &ForInStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(3), Default::default())\\n };\\n keyword!(span, \"for\");\\n }\\n punct!(\"(\");\\n emit!(n.left);\\n\\n if n.left.ends_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n keyword!(\"in\");\\n\\n {\\n let starts_with_alpha_num = n.right.starts_with_alpha_num();\\n\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!()\\n }\\n emit!(n.right);\\n }\\n\\n punct!(\")\");\\n\\n emit!(n.body);\\n }\\n\\n #[emitter]\\n fn emit_for_of_stmt(&mut self, n: &ForOfStmt) -> Result {\\n self.emit_leading_comments_of_span(n.span(), false)?;\\n\\n {\\n let span = if n.span.is_dummy() {\\n DUMMY_SP\\n } else {\\n Span::new(n.span.lo, n.span.lo + BytePos(3), Default::default())\\n };\\n keyword!(span, \"for\");\\n }\\n if n.await_token.is_some() {\\n space!();\\n keyword!(\"await\");\\n }\\n formatting_space!();\\n punct!(\"(\");\\n emit!(n.left);\\n if n.left.ends_with_alpha_num() {\\n space!();\\n } else {\\n formatting_space!();\\n }\\n keyword!(\"of\");\\n\\n {\\n let starts_with_alpha_num = n.right.starts_with_alpha_num();\\n\\n if starts_with_alpha_num {\\n space!();\\n } else {\\n formatting_space!()\\n }\\n emit!(n.right);\\n }\\n punct!(\")\");\\n emit!(n.body);\\n }\\n}\\n\\nimpl<\\'a, W> Emitter<\\'a, W>\\nwhere\\n W: WriteJs,\\n{\\n fn write_delim(&mut self, f: ListFormat) -> Result {\\n match f & ListFormat::DelimitersMask {\\n ListFormat::None => {}\\n ListFormat::CommaDelimited => self.wr.write_punct(None, \",\")?,\\n ListFormat::BarDelimited => {\\n if !self.cfg.minify {\\n self.wr.write_space()?;\\n }\\n self.wr.write_punct(None, \"|\")?;\\n }\\n ListFormat::AmpersandDelimited => {\\n if !self.cfg.minify {\\n self.wr.write_space()?;\\n }\\n self.wr.write_punct(None, \"&\")?;\\n }\\n _ => unreachable!(),\\n }\\n\\n Ok(())\\n }\\n\\n #[emitter]\\n fn emit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) -> Result {\\n match *node {\\n VarDeclOrExpr::Expr(ref node) => emit!(node),\\n VarDeclOrExpr::VarDecl(ref node) => emit!(node),\\n }\\n }\\n}\\n\\n#[allow(dead_code)]\\nfn get_text_of_node(\\n cm: &Arc,\\n node: &T,\\n _include_travia: bool,\\n) -> Option {\\n let span = node.span();\\n if span.is_dummy() || span.ctxt() != SyntaxContext::empty() {\\n // This node is transformed so we shoukld not use original source code.\\n return None;\\n }\\n\\n let s = cm.span_to_snippet(span).unwrap();\\n if s == \"\" {\\n return None;\\n }\\n Some(s)\\n}\\n\\n/// In some cases, we need to emit a space between the operator and the operand.\\n/// One obvious case is when the operator is an identifier, like delete or\\n/// typeof. We also need to do this for plus and minus expressions in certain\\n/// cases. Specifically, consider the following two cases (parens are just for\\n/// clarity of exposition, and not part of the source code):\\n///\\n/// (+(+1))\\n/// (+(++1))\\n///\\n/// We need to emit a space in both cases. In the first case, the absence of a\\n/// space will make the resulting expression a prefix increment operation. And\\n/// in the second, it will make the resulting expression a prefix increment\\n/// whose operand is a plus expression - (++(+x)) The same is true of minus of\\n/// course.\\nfn should_emit_whitespace_before_operand(node: &UnaryExpr) -> bool {\\n match *node {\\n UnaryExpr {\\n op: op!(\"void\"), ..\\n }\\n | UnaryExpr {\\n op: op!(\"typeof\"), ..\\n }\\n | UnaryExpr {\\n op: op!(\"delete\"), ..\\n } => return node.arg.starts_with_alpha_num(),\\n _ => {}\\n }\\n\\n match *node.arg {\\n Expr::Update(UpdateExpr {\\n op: op!(\"++\"),\\n prefix: true,\\n ..\\n })\\n | Expr::Unary(UnaryExpr {\\n op: op!(unary, \"+\"),\\n ..\\n }) if node.op == op!(unary, \"+\") => true,\\n Expr::Update(UpdateExpr {\\n op: op!(\"--\"),\\n prefix: true,\\n ..\\n })\\n | Expr::Unary(UnaryExpr {\\n op: op!(unary, \"-\"),\\n ..\\n }) if node.op == op!(unary, \"-\") => true,\\n _ => false,\\n }\\n}\\n\\nimpl Node for Option\\nwhere\\n N: Node,\\n{\\n fn emit_with(&self, e: &mut Emitter<\\'_, W>) -> Result\\n where\\n W: WriteJs,\\n {\\n match *self {\\n Some(ref n) => n.emit_with(e),\\n None => Ok(()),\\n }\\n }\\n}\\n\\nfn unescape_tpl_lit(s: &str, is_synthesized: bool) -> String {\\n fn read_escaped(\\n radix: u32,\\n len: Option,\\n buf: &mut String,\\n chars: impl Iterator,\\n ) {\\n let mut v = 0;\\n let mut pending = None;\\n\\n for (i, c) in chars.enumerate() {\\n if let Some(len) = len {\\n if i == len {\\n pending = Some(c);\\n break;\\n }\\n }\\n\\n match c.to_digit(radix) {\\n None => {\\n pending = Some(c);\\n break;\\n }\\n Some(d) => {\\n v = v * radix + d;\\n }\\n }\\n }\\n\\n match radix {\\n 2 => write!(buf, \"\\\\\\\\b{:b}\", v).unwrap(),\\n\\n 8 => write!(buf, \"\\\\\\\\o{:o}\", v).unwrap(),\\n\\n 16 => {\\n if v < 16 {\\n write!(buf, \"\\\\\\\\x0{:x}\", v).unwrap()\\n } else {\\n write!(buf, \"\\\\\\\\x{:x}\", v).unwrap()\\n }\\n }\\n\\n _ => unreachable!(),\\n }\\n\\n if let Some(pending) = pending {\\n buf.push(pending);\\n }\\n }\\n\\n let mut result = String::with_capacity(s.len() * 6 / 5);\\n let mut chars = s.chars().peekable();\\n\\n while let Some(c) = chars.next() {\\n if c != \\'\\\\\\\\\\' {\\n match c {\\n \\'\\\\r\\' => {\\n if chars.peek().map(|&v| v) == Some(\\'\\\\n\\') {\\n continue;\\n }\\n\\n result.push_str(\"\\\\r\");\\n }\\n \\'\\\\n\\' => {\\n result.push_str(\"\\\\n\");\\n }\\n\\n \\'`\\' if is_synthesized => {\\n result.push_str(\"\\\\\\\\`\");\\n }\\n\\n // TODO: Handle all escapes\\n _ => {\\n result.push(c);\\n }\\n }\\n\\n continue;\\n }\\n\\n match chars.next() {\\n None => {\\n // This is wrong, but it seems like a mistake made by user.\\n result.push(\\'\\\\\\\\\\');\\n }\\n Some(c) => {\\n match c {\\n \\'\\\\\\\\\\' => result.push_str(r\"\\\\\\\\\"),\\n \\'n\\' => result.push_str(\"\\\\\\\\n\"),\\n \\'r\\' => result.push_str(\"\\\\\\\\r\"),\\n \\'t\\' => result.push_str(\"\\\\\\\\t\"),\\n \\'b\\' => result.push_str(\"\\\\\\\\\\\\u{0008}\"),\\n \\'f\\' => result.push_str(\"\\\\\\\\\\\\u{000C}\"),\\n \\'v\\' => result.push_str(\"\\\\\\\\\\\\u{000B}\"),\\n \\'0\\' => match chars.next() {\\n Some(\\'b\\') => read_escaped(2, None, &mut result, &mut chars),\\n Some(\\'o\\') => read_escaped(8, None, &mut result, &mut chars),\\n Some(\\'x\\') => read_escaped(16, Some(2), &mut result, &mut chars),\\n nc => {\\n // This is wrong, but it seems like a mistake made by user.\\n result.push_str(\"\\\\\\\\0\");\\n result.extend(nc);\\n }\\n },\\n\\n _ => {\\n result.push(\\'\\\\\\\\\\');\\n result.push(c);\\n }\\n }\\n }\\n }\\n }\\n\\n result\\n}\\n\\nfn escape_without_source(v: &str, target: JscTarget, single_quote: bool) -> String {\\n let mut buf = String::with_capacity(v.len());\\n let mut iter = v.chars().peekable();\\n\\n while let Some(c) = iter.next() {\\n match c {\\n \\'\\\\u{0008}\\' => buf.push_str(\"\\\\\\\\b\"),\\n \\'\\\\u{000c}\\' => buf.push_str(\"\\\\\\\\f\"),\\n \\'\\\\n\\' => buf.push_str(\"\\\\\\\\n\"),\\n \\'\\\\r\\' => buf.push_str(\"\\\\\\\\r\"),\\n \\'\\\\t\\' => buf.push_str(\"\\\\\\\\t\"),\\n \\'\\\\u{000b}\\' => buf.push_str(\"\\\\\\\\v\"),\\n \\'\\\\0\\' => buf.push_str(\"\\\\\\\\x00\"),\\n\\n \\'\\\\\\\\\\' => {\\n if iter.peek() == Some(&\\'\\\\0\\') {\\n buf.push_str(\"\\\\\\\\\");\\n iter.next();\\n } else {\\n buf.push_str(\"\\\\\\\\\\\\\\\\\")\\n }\\n }\\n\\n \\'\\\\\\'\\' if single_quote => buf.push_str(\"\\\\\\\\\\'\"),\\n \\'\"\\' if !single_quote => buf.push_str(\"\\\\\\\\\\\\\"\"),\\n\\n \\'\\\\x01\\'..=\\'\\\\x0f\\' => {\\n let _ = write!(buf, \"\\\\\\\\x0{:x}\", c as u8);\\n }\\n \\'\\\\x10\\'..=\\'\\\\x1f\\' => {\\n let _ = write!(buf, \"\\\\\\\\x{:x}\", c as u8);\\n }\\n\\n \\'\\\\x20\\'..=\\'\\\\x7e\\' => {\\n //\\n buf.push(c);\\n }\\n \\'\\\\u{7f}\\'..=\\'\\\\u{ff}\\' => {\\n let _ = write!(buf, \"\\\\\\\\x{:x}\", c as u8);\\n }\\n\\n \\'\\\\u{2028}\\' => {\\n buf.push_str(\"\\\\\\\\u2028\");\\n }\\n \\'\\\\u{2029}\\' => {\\n buf.push_str(\"\\\\\\\\u2029\");\\n }\\n\\n _ => {\\n buf.push(c);\\n }\\n }\\n }\\n\\n buf\\n}\\n\\nfn escape_with_source<\\'s>(\\n cm: &SourceMap,\\n target: JscTarget,\\n span: Span,\\n s: &\\'s str,\\n single_quote: Option,\\n) -> String {\\n if target <= JscTarget::Es5 {\\n return escape_without_source(s, target, single_quote.unwrap_or(false));\\n }\\n\\n if span.is_dummy() {\\n return escape_without_source(s, target, single_quote.unwrap_or(false));\\n }\\n\\n //\\n let orig = cm.span_to_snippet(span);\\n let orig = match orig {\\n Ok(orig) => orig,\\n Err(v) => {\\n return escape_without_source(s, target, single_quote.unwrap_or(false));\\n }\\n };\\n\\n if single_quote.is_some() && orig.len() <= 2 {\\n return escape_without_source(s, target, single_quote.unwrap_or(false));\\n }\\n\\n let mut orig = &*orig;\\n\\n if (single_quote == Some(true) && orig.starts_with(\\'\\\\\\'\\'))\\n || (single_quote == Some(false) && orig.starts_with(\\'\"\\'))\\n {\\n orig = &orig[1..orig.len() - 1];\\n } else {\\n if single_quote.is_some() {\\n return escape_without_source(s, target, single_quote.unwrap_or(false));\\n }\\n }\\n\\n let mut buf = String::with_capacity(s.len());\\n let mut orig_iter = orig.chars().peekable();\\n let mut s_iter = s.chars();\\n\\n while let Some(orig_c) = orig_iter.next() {\\n // Javascript literal should not contain newlines\\n if orig_c == \\'\\\\n\\' {\\n s_iter.next();\\n s_iter.next();\\n buf.push_str(\"\\\\\\\\n\");\\n continue;\\n }\\n\\n if single_quote.is_none() && orig_c == \\'\"\\' {\\n s_iter.next();\\n s_iter.next();\\n buf.push_str(\"\\\\\\\\\\\\\"\");\\n continue;\\n }\\n\\n if orig_c == \\'\\\\\\\\\\' {\\n if s_iter.as_str().starts_with(\"\\\\\\\\\\\\0\") {\\n for _ in 0..6 {\\n s_iter.next();\\n }\\n }\\n\\n buf.push(\\'\\\\\\\\\\');\\n match orig_iter.next() {\\n Some(\\'\\\\\\\\\\') => {\\n buf.push(\\'\\\\\\\\\\');\\n s_iter.next();\\n continue;\\n }\\n Some(escaper) => {\\n buf.push(escaper);\\n match escaper {\\n \\'x\\' => {\\n buf.extend(orig_iter.next());\\n buf.extend(orig_iter.next());\\n s_iter.next();\\n }\\n \\'u\\' => match orig_iter.next() {\\n Some(\\'{\\') => {\\n buf.push(\\'{\\');\\n loop {\\n let ch = orig_iter.next();\\n buf.extend(ch);\\n if ch == Some(\\'}\\') {\\n break;\\n }\\n }\\n s_iter.next();\\n }\\n Some(ch) => {\\n buf.push(ch);\\n buf.extend(orig_iter.next());\\n buf.extend(orig_iter.next());\\n buf.extend(orig_iter.next());\\n s_iter.next();\\n }\\n None => break,\\n },\\n \\'b\\' | \\'f\\' | \\'n\\' | \\'r\\' | \\'t\\' | \\'v\\' | \\'0\\' => {\\n s_iter.next();\\n }\\n\\n \\'\\\\\\'\\' if single_quote == Some(true) => {\\n s_iter.next();\\n }\\n\\n \\'\"\\' if single_quote == Some(false) => {\\n s_iter.next();\\n }\\n\\n _ => {\\n s_iter.next();\\n }\\n }\\n\\n continue;\\n }\\n _ => {}\\n }\\n }\\n\\n s_iter.next();\\n buf.push(orig_c);\\n }\\n\\n buf.extend(s_iter);\\n\\n buf\\n}\\n\\n/// Returns [Some] if the span points to a string literal written by user.\\n///\\n/// Returns [None] if the span is created from a pass of swc. For example,\\n/// spans of string literals created from [TplElement] do not have `starting`\\n/// quote.\\nfn is_single_quote(cm: &SourceMap, span: Span) -> Option {\\n if span.is_dummy() {\\n return None;\\n }\\n\\n let start = cm.lookup_byte_offset(span.lo);\\n let end = cm.lookup_byte_offset(span.hi);\\n\\n if start.sf.start_pos != end.sf.start_pos {\\n return None;\\n }\\n\\n // Empty file\\n if start.sf.start_pos == start.sf.end_pos {\\n return None;\\n }\\n\\n let start_index = start.pos.0;\\n let end_index = end.pos.0;\\n let source_len = (start.sf.end_pos - start.sf.start_pos).0;\\n\\n if start_index > end_index || end_index > source_len {\\n return None;\\n }\\n\\n let src = &start.sf.src;\\n let single_quote = match src.as_bytes()[start_index as usize] {\\n b\\'\\\\\\'\\' => true,\\n b\\'\"\\' => false,\\n _ => return None,\\n };\\n if end_index == 0 {\\n return None;\\n }\\n\\n if src.as_bytes()[start_index as usize] != src.as_bytes()[(end_index - 1) as usize] {\\n return None;\\n }\\n\\n Some(single_quote)\\n}\\n\\nfn handle_invalid_unicodes(s: &str) -> Cow {\\n static NEEDLE: Lazy = Lazy::new(|| Finder::new(\"\\\\\\\\\\\\0\"));\\n if NEEDLE.find(s.as_bytes()).is_none() {\\n return Cow::Borrowed(s);\\n }\\n\\n Cow::Owned(s.replace(\"\\\\\\\\\\\\0\", \"\\\\\\\\\"))\\n}\\n',\n", + " 'content_id': '18da3499eaff18e446b44218f67492396967a9ed',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/codegen/src/lib.rs',\n", + " 'size': 89509,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4021107668474051,\n", + " 'avg_line_length': 34.73702422145329,\n", + " 'blob_id': '0410d73571ab0d43a135530c9698760596488829',\n", + " 'content': 'use crate::loaders::json::load_json_as_module;\\nuse anyhow::{bail, Context, Error};\\nuse helpers::Helpers;\\nuse rustc_hash::FxHashMap;\\nuse std::{collections::HashMap, env, sync::Arc};\\nuse swc::{\\n config::{InputSourceMap, JscConfig, TransformConfig},\\n try_with_handler,\\n};\\nuse swc_atoms::JsWord;\\nuse swc_bundler::{Load, ModuleData};\\nuse swc_common::{errors::Handler, sync::Lrc, FileName, DUMMY_SP};\\nuse swc_ecma_ast::{Expr, Lit, Module, Program, Str};\\nuse swc_ecma_parser::{lexer::Lexer, JscTarget, Parser, StringInput, Syntax};\\nuse swc_ecma_transforms::{\\n helpers,\\n optimization::{\\n inline_globals,\\n simplify::{dead_branch_remover, expr_simplifier},\\n },\\n pass::noop,\\n};\\nuse swc_ecma_visit::FoldWith;\\n\\n/// JavaScript loader\\npub struct SwcLoader {\\n compiler: Arc,\\n options: swc::config::Options,\\n}\\n\\nimpl SwcLoader {\\n pub fn new(compiler: Arc, options: swc::config::Options) -> Self {\\n SwcLoader { compiler, options }\\n }\\n\\n fn env_map(&self) -> Lrc> {\\n let mut m = HashMap::default();\\n\\n let envs = self\\n .options\\n .config\\n .jsc\\n .transform\\n .as_ref()\\n .and_then(|t| t.optimizer.as_ref())\\n .and_then(|o| o.globals.as_ref())\\n .and_then(|g| Some(g.envs.clone()))\\n .unwrap_or_default();\\n\\n let envs_map: FxHashMap<_, _> = envs\\n .into_iter()\\n .map(|name| {\\n let value = env::var(&name).ok();\\n (name, value.unwrap_or_default())\\n })\\n .collect();\\n\\n for (k, v) in envs_map {\\n m.insert(\\n k.into(),\\n Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: v.into(),\\n has_escape: false,\\n kind: Default::default(),\\n })),\\n );\\n }\\n\\n Lrc::new(m)\\n }\\n\\n fn load_with_handler(&self, handler: &Handler, name: &FileName) -> Result {\\n tracing::debug!(\"JsLoader.load({})\", name);\\n let helpers = Helpers::new(false);\\n\\n match name {\\n FileName::Custom(id) => {\\n // Handle built-in modules\\n if id.starts_with(\"node:\") {\\n let fm = self\\n .compiler\\n .cm\\n .new_source_file(name.clone(), \"\".to_string());\\n return Ok(ModuleData {\\n fm,\\n module: Module {\\n span: DUMMY_SP,\\n body: Default::default(),\\n shebang: Default::default(),\\n },\\n helpers: Default::default(),\\n });\\n // Handle disabled modules, eg when `browser` has a field\\n // set to `false`\\n } else {\\n // TODO: When we know the calling context is ESM\\n // TODO: switch to `export default {}`.\\n let fm = self\\n .compiler\\n .cm\\n .new_source_file(name.clone(), \"module.exports = {}\".to_string());\\n let lexer = Lexer::new(\\n Syntax::Es(Default::default()),\\n Default::default(),\\n StringInput::from(&*fm),\\n None,\\n );\\n let mut parser = Parser::new_from(lexer);\\n let module = parser.parse_module().unwrap();\\n return Ok(ModuleData {\\n fm,\\n module,\\n helpers: Default::default(),\\n });\\n }\\n }\\n _ => {}\\n }\\n\\n let fm = self\\n .compiler\\n .cm\\n .load_file(match name {\\n FileName::Real(v) => &v,\\n _ => bail!(\"swc-loader only accepts path. Got `{}`\", name),\\n })\\n .with_context(|| format!(\"failed to load file `{}`\", name))?;\\n\\n match name {\\n FileName::Real(path) => {\\n if let Some(ext) = path.extension() {\\n if ext == \"json\" {\\n let module = load_json_as_module(&fm)\\n .with_context(|| format!(\"failed to load json file at {}\", fm.name))?;\\n return Ok(ModuleData {\\n fm: fm.clone(),\\n module,\\n helpers: Default::default(),\\n });\\n }\\n }\\n }\\n _ => {}\\n }\\n\\n tracing::trace!(\"JsLoader.load: loaded\");\\n\\n let program = if fm.name.to_string().contains(\"node_modules\") {\\n let program = self.compiler.parse_js(\\n fm.clone(),\\n &handler,\\n JscTarget::Es2020,\\n Default::default(),\\n true,\\n true,\\n )?;\\n let program = helpers::HELPERS.set(&helpers, || {\\n swc_ecma_utils::HANDLER.set(&handler, || {\\n let program =\\n program.fold_with(&mut inline_globals(self.env_map(), Default::default()));\\n let program = program.fold_with(&mut expr_simplifier(Default::default()));\\n let program = program.fold_with(&mut dead_branch_remover());\\n\\n program\\n })\\n });\\n\\n program\\n } else {\\n let config = self.compiler.config_for_file(\\n handler,\\n &swc::config::Options {\\n config: {\\n let c = &self.options.config;\\n swc::config::Config {\\n jsc: JscConfig {\\n transform: {\\n if let Some(c) = &c.jsc.transform {\\n Some(TransformConfig {\\n react: c.react.clone(),\\n const_modules: c.const_modules.clone(),\\n optimizer: None,\\n legacy_decorator: c.legacy_decorator,\\n decorator_metadata: c.decorator_metadata,\\n hidden: Default::default(),\\n })\\n } else {\\n None\\n }\\n },\\n external_helpers: true,\\n ..c.jsc.clone()\\n },\\n module: None,\\n minify: false,\\n input_source_map: InputSourceMap::Bool(false),\\n ..c.clone()\\n }\\n },\\n skip_helper_injection: true,\\n disable_hygiene: false,\\n disable_fixer: true,\\n global_mark: self.options.global_mark,\\n cwd: self.options.cwd.clone(),\\n caller: None,\\n filename: String::new(),\\n config_file: None,\\n root: None,\\n root_mode: Default::default(),\\n swcrc: true,\\n swcrc_roots: Default::default(),\\n env_name: {\\n let s = env::var(\"NODE_ENV\").unwrap_or_else(|_| \"development\".into());\\n s\\n },\\n source_maps: None,\\n source_file_name: None,\\n source_root: None,\\n is_module: true,\\n output_path: None,\\n ..Default::default()\\n },\\n &fm.name,\\n noop(),\\n )?;\\n\\n tracing::trace!(\"JsLoader.load: loaded config\");\\n\\n // We run transform at this phase to strip out unused dependencies.\\n //\\n // Note that we don\\'t apply compat transform at loading phase.\\n let program = self.compiler.parse_js(\\n fm.clone(),\\n handler,\\n JscTarget::Es2020,\\n config.as_ref().map(|v| v.syntax).unwrap_or_default(),\\n true,\\n true,\\n );\\n let program = if config.is_some() {\\n program?\\n } else {\\n program.context(\"tried to parse as ecmascript as it\\'s excluded by .swcrc\")?\\n };\\n\\n tracing::trace!(\"JsLoader.load: parsed\");\\n\\n // Fold module\\n let program = if let Some(mut config) = config {\\n helpers::HELPERS.set(&helpers, || {\\n swc_ecma_utils::HANDLER.set(handler, || {\\n let program = program\\n .fold_with(&mut inline_globals(self.env_map(), Default::default()));\\n let program = program.fold_with(&mut expr_simplifier(Default::default()));\\n let program = program.fold_with(&mut dead_branch_remover());\\n\\n let program = program.fold_with(&mut config.pass);\\n\\n program\\n })\\n })\\n } else {\\n program\\n };\\n\\n tracing::trace!(\"JsLoader.load: applied transforms\");\\n\\n program\\n };\\n\\n match program {\\n Program::Module(module) => Ok(ModuleData {\\n fm,\\n module,\\n helpers,\\n }),\\n _ => unreachable!(),\\n }\\n }\\n}\\n\\nimpl Load for SwcLoader {\\n fn load(&self, name: &FileName) -> Result {\\n try_with_handler(self.compiler.cm.clone(), |handler| {\\n self.load_with_handler(&handler, name)\\n })\\n }\\n}\\n',\n", + " 'content_id': '8bacb527138b310a98299f606824e6e64414a16f',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/node/bundler/src/loaders/swc.rs',\n", + " 'size': 10328,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6256,\n", + " 'avg_line_length': 28.069767441860463,\n", + " 'blob_id': '4dc38e1fa83e67b6edbe73ad5c205511a154b9d0',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Common utilities for the swc project.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_common/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_common\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.13.3\"\\n\\n[features]\\nconcurrent = [\"parking_lot\"]\\ndebug = []\\ndefault = []\\ntty-emitter = [\"atty\", \"termcolor\"]\\n\\n[dependencies]\\nahash = \"0.7.4\"\\narbitrary = {version = \"1\", optional = true, features = [\"derive\"]}\\nast_node = {version = \"0.7.3\", path = \"../macros/ast_node\"}\\natty = {version = \"0.2\", optional = true}\\ncfg-if = \"0.1.2\"\\neither = \"1.5\"\\nfrom_variant = {version = \"0.1.3\", path = \"../macros/from_variant\"}\\nnum-bigint = \"0.2\"\\nonce_cell = \"1\"\\nowning_ref = \"0.4\"\\nparking_lot = {version = \"0.7.1\", optional = true}\\nrustc-hash = \"1.1.0\"\\nscoped-tls = {version = \"1\"}\\nserde = {version = \"1.0.119\", features = [\"derive\"]}\\nsourcemap = {version = \"6\", optional = true}\\nstring_cache = \"0.8.1\"\\nswc_eq_ignore_macros = {version = \"0.1\", path = \"../macros/eq_ignore\"}\\nswc_visit = {version = \"0.2.4\", path = \"../visit\"}\\ntermcolor = {version = \"1.0\", optional = true}\\ntracing = \"0.1.28\"\\nunicode-width = \"0.1.4\"\\nurl = \"2.2.2\"\\n\\n[dev-dependencies]\\nrayon = \"1\"\\nserde_json = \"1\"\\n',\n", + " 'content_id': '725e207bf7643717d225a45e58807dae4713a477',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 70,\n", + " 'path': '/common/Cargo.toml',\n", + " 'size': 1250,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4960112623181605,\n", + " 'avg_line_length': 27.604026845637584,\n", + " 'blob_id': '64c767f86437b72399fbc4e58ce76b56be48df2c',\n", + " 'content': 'use crate::option::MangleOptions;\\nuse rustc_hash::FxHashSet;\\nuse swc_common::DUMMY_SP;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{find_ids, ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_type, Node, Visit, VisitWith};\\n\\npub(super) fn idents_to_preserve(options: MangleOptions, n: &N) -> FxHashSet\\nwhere\\n N: VisitWith,\\n{\\n let mut v = Preserver {\\n options,\\n preserved: Default::default(),\\n should_preserve: false,\\n in_top_level: false,\\n };\\n n.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n v.preserved\\n}\\npub(super) struct Preserver {\\n options: MangleOptions,\\n preserved: FxHashSet,\\n should_preserve: bool,\\n in_top_level: bool,\\n}\\n\\nimpl Visit for Preserver {\\n noop_visit_type!();\\n\\n fn visit_class_decl(&mut self, n: &ClassDecl, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if (self.in_top_level && !self.options.top_level) || self.options.keep_class_names {\\n self.preserved.insert(n.ident.to_id());\\n }\\n }\\n\\n fn visit_catch_clause(&mut self, n: &CatchClause, _: &dyn Node) {\\n let old = self.should_preserve;\\n\\n if self.options.ie8 && !self.options.top_level {\\n self.should_preserve = true;\\n n.param.visit_with(&Invalid { span: DUMMY_SP }, self);\\n }\\n\\n self.should_preserve = old;\\n n.body.visit_with(&Invalid { span: DUMMY_SP }, self);\\n }\\n\\n fn visit_export_decl(&mut self, n: &ExportDecl, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n match &n.decl {\\n Decl::Class(c) => {\\n self.preserved.insert(c.ident.to_id());\\n }\\n Decl::Fn(f) => {\\n self.preserved.insert(f.ident.to_id());\\n }\\n Decl::Var(v) => {\\n let ids: Vec = find_ids(&v.decls);\\n self.preserved.extend(ids);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_expr(&mut self, n: &Expr, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n match n {\\n Expr::Ident(i) => {\\n if self.should_preserve {\\n self.preserved.insert(i.to_id());\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_fn_decl(&mut self, n: &FnDecl, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if (self.in_top_level && !self.options.top_level) || self.options.keep_fn_names {\\n self.preserved.insert(n.ident.to_id());\\n }\\n }\\n\\n fn visit_member_expr(&mut self, n: &MemberExpr, _: &dyn Node) {\\n n.obj.visit_with(n, self);\\n if n.computed {\\n n.prop.visit_with(n, self);\\n }\\n }\\n\\n fn visit_module_items(&mut self, n: &[ModuleItem], _: &dyn Node) {\\n for n in n {\\n self.in_top_level = true;\\n n.visit_with(&Invalid { span: DUMMY_SP }, self);\\n }\\n }\\n\\n fn visit_pat(&mut self, n: &Pat, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n match n {\\n Pat::Ident(i) => {\\n if self.should_preserve {\\n self.preserved.insert(i.to_id());\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_stmts(&mut self, n: &[Stmt], _: &dyn Node) {\\n let old_top_level = self.in_top_level;\\n for n in n {\\n self.in_top_level = false;\\n n.visit_with(&Invalid { span: DUMMY_SP }, self);\\n }\\n self.in_top_level = old_top_level;\\n }\\n\\n fn visit_var_declarator(&mut self, n: &VarDeclarator, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if self.in_top_level && !self.options.top_level {\\n let old = self.should_preserve;\\n self.should_preserve = true;\\n n.name.visit_with(n, self);\\n self.should_preserve = old;\\n return;\\n }\\n\\n if self.options.keep_fn_names {\\n match n.init.as_deref() {\\n Some(Expr::Fn(..)) | Some(Expr::Arrow(..)) => {\\n let old = self.should_preserve;\\n self.should_preserve = true;\\n n.name.visit_with(n, self);\\n self.should_preserve = old;\\n }\\n _ => {}\\n }\\n }\\n }\\n}\\n',\n", + " 'content_id': '907ac7096efea59fb51cb856648451126c0d491e',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 92,\n", + " 'path': '/ecmascript/minifier/src/pass/mangle_names/preserver.rs',\n", + " 'size': 4262,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4003609565348173,\n", + " 'avg_line_length': 30.966346153846153,\n", + " 'blob_id': 'c5f15d293f88bf918bdad13ab7bbe0f0ac019d09',\n", + " 'content': 'use crate::resolve::Resolve;\\nuse anyhow::{bail, Context, Error};\\nuse dashmap::DashMap;\\nuse once_cell::sync::Lazy;\\nuse regex::Regex;\\nuse std::path::{Component, PathBuf};\\nuse swc_common::FileName;\\n\\n#[derive(Debug)]\\nenum Pattern {\\n Regex(Regex),\\n /// No wildcard.\\n Exact(String),\\n}\\n\\n/// Support for `paths` of `tsconfig.json`.\\n///\\n/// See https://www.typescriptlang.org/docs/handbook/module-resolution.html#path-mapping\\n#[derive(Debug)]\\npub struct TsConfigResolver\\nwhere\\n R: Resolve,\\n{\\n inner: R,\\n base_url: PathBuf,\\n paths: Vec<(Pattern, Vec)>,\\n}\\n\\nimpl TsConfigResolver\\nwhere\\n R: Resolve,\\n{\\n ///\\n /// # Parameters\\n ///\\n /// ## base_url\\n ///\\n /// See https://www.typescriptlang.org/tsconfig#baseUrl\\n ///\\n /// The typescript documentation says `This must be specified if \"paths\"\\n /// is.`.\\n ///\\n /// ## `paths`\\n ///\\n /// Pass `paths` map from `tsconfig.json`.\\n ///\\n /// See https://www.typescriptlang.org/tsconfig#paths\\n ///\\n /// Note that this is not a hashmap because value is not used as a hash map.\\n pub fn new(inner: R, base_url: PathBuf, paths: Vec<(String, Vec)>) -> Self {\\n let paths = paths\\n .into_iter()\\n .map(|(from, to)| {\\n assert!(\\n !to.is_empty(),\\n \"value of `paths.{}` should not be an empty array\",\\n from,\\n );\\n\\n let pat = if from.contains(\\'*\\') {\\n if from.as_bytes().iter().rposition(|&c| c == b\\'*\\')\\n != from.as_bytes().iter().position(|&c| c == b\\'*\\')\\n {\\n panic!(\"`paths.{}` should have only one wildcard\", from)\\n }\\n\\n Pattern::Regex(compile_regex(from))\\n } else {\\n assert_eq!(\\n to.len(),\\n 1,\\n \"value of `paths.{}` should be an array with one element because the src \\\\\\n path does not contains * (wildcard)\",\\n from,\\n );\\n\\n Pattern::Exact(from)\\n };\\n\\n (pat, to)\\n })\\n .collect();\\n\\n Self {\\n inner,\\n base_url,\\n paths,\\n }\\n }\\n}\\n\\nimpl Resolve for TsConfigResolver\\nwhere\\n R: Resolve,\\n{\\n fn resolve(&self, base: &FileName, src: &str) -> Result {\\n if src.starts_with(\".\") {\\n if src == \"..\" || src.starts_with(\"./\") || src.starts_with(\"../\") {\\n return self\\n .inner\\n .resolve(base, src)\\n .context(\"not processed by tsc resolver because it\\'s relative import\");\\n }\\n }\\n\\n match base {\\n FileName::Real(v) => {\\n if v.components().any(|c| match c {\\n Component::Normal(v) => v == \"node_modules\",\\n _ => false,\\n }) {\\n return self.inner.resolve(base, src).context(\\n \"not processed by tsc resolver because base module is in node_modules\",\\n );\\n }\\n }\\n _ => {}\\n }\\n\\n // https://www.typescriptlang.org/docs/handbook/module-resolution.html#path-mapping\\n for (from, to) in &self.paths {\\n match from {\\n Pattern::Regex(from) => {\\n let captures = from.captures(src);\\n let captures = match captures {\\n Some(v) => v,\\n None => continue,\\n };\\n\\n let mut iter = captures.iter();\\n let _ = iter.next();\\n\\n let capture = iter.next().flatten().expect(\\n \"capture group should be created by initializer of TsConfigResolver\",\\n );\\n let mut errors = vec![];\\n for target in to {\\n let mut replaced = target.replace(\\'*\\', capture.as_str());\\n let rel = format!(\"./{}\", replaced);\\n\\n let res = self.inner.resolve(base, &rel).with_context(|| {\\n format!(\\n \"failed to resolve `{}`, which is expanded from `{}`\",\\n replaced, src\\n )\\n });\\n\\n errors.push(match res {\\n Ok(v) => return Ok(v),\\n Err(err) => err,\\n });\\n\\n if cfg!(target_os = \"windows\") {\\n if replaced.starts_with(\"./\") {\\n replaced = replaced[2..].to_string();\\n }\\n replaced = replaced.replace(\\'/\\', \"\\\\\\\\\");\\n }\\n\\n if to.len() == 1 {\\n return Ok(FileName::Real(self.base_url.join(replaced)));\\n }\\n }\\n\\n bail!(\\n \"`{}` matched `{}` (from tsconfig.paths) but failed to resolve:\\\\n{:?}\",\\n src,\\n from.as_str(),\\n errors\\n )\\n }\\n Pattern::Exact(from) => {\\n // Should be exactly matched\\n if src == from {\\n return self\\n .inner\\n .resolve(base, &format!(\"./{}\", &to[0]))\\n .with_context(|| {\\n format!(\\n \"tried to resolve `{}` because `{}` was exactly matched\",\\n to[0], from\\n )\\n });\\n }\\n }\\n }\\n }\\n\\n self.inner.resolve(base, src)\\n }\\n}\\n\\nfn compile_regex(src: String) -> Regex {\\n static CACHE: Lazy> = Lazy::new(|| Default::default());\\n\\n if !CACHE.contains_key(&*src) {\\n // Create capture group\\n let regex_pat = src.replace(\"*\", \"(.*)\");\\n let re = Regex::new(®ex_pat).unwrap_or_else(|err| {\\n panic!(\"failed to compile `{}` as a pattern: {:?}\", regex_pat, err)\\n });\\n CACHE.insert(src.clone(), re);\\n }\\n\\n let re = CACHE.get(&*src).unwrap();\\n\\n (*re).clone()\\n}\\n',\n", + " 'content_id': 'c3a1281abeecf0c54d51859de5139185175a24a8',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/ecmascript/loader/src/resolvers/tsc.rs',\n", + " 'size': 6649,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5285798467884502,\n", + " 'avg_line_length': 25.107692307692307,\n", + " 'blob_id': '847c41171f0e8128a815b463eab6adcdc1e67e03',\n", + " 'content': 'use self::scope::Scope;\\nuse crate::{Hook, Load, ModuleId, Resolve};\\nuse ahash::AHashMap;\\nuse anyhow::{Context, Error};\\nuse std::collections::HashMap;\\nuse swc_atoms::JsWord;\\nuse swc_common::{sync::Lrc, FileName, Globals, Mark, SourceMap, SyntaxContext, GLOBALS};\\nuse swc_ecma_ast::Module;\\n\\nmod chunk;\\nmod export;\\nmod finalize;\\nmod helpers;\\nmod import;\\nmod keywords;\\nmod load;\\nmod optimize;\\nmod scope;\\n#[cfg(test)]\\npub(crate) mod tests;\\n\\n#[derive(Debug, Default)]\\npub struct Config {\\n /// If it\\'s true, [Bundler] searches for require calls.\\n pub require: bool,\\n\\n /// If it\\'s true, many temporary variables will be generated.\\n ///\\n /// This option exists mainly for testing. As inlining and dce removes all\\n /// temporary variables, it\\'s really hard to see what\\'s going on.\\n pub disable_inliner: bool,\\n\\n /// List of modules which should be preserved.\\n pub external_modules: Vec,\\n\\n /// Type of emitted module\\n pub module: ModuleType,\\n}\\n\\n#[derive(Debug, PartialEq, Eq, Hash)]\\npub enum ModuleType {\\n Es,\\n Iife,\\n}\\n\\nimpl Default for ModuleType {\\n fn default() -> Self {\\n ModuleType::Es\\n }\\n}\\n\\n#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\\npub enum BundleKind {\\n /// User-provided entry\\n Named { name: String },\\n /// Auto-generated entry (created by import expression)\\n Dynamic,\\n /// A lazy-loaded shared library\\n Lib { name: String },\\n}\\n\\n/// Built bundle\\n#[derive(Debug)]\\npub struct Bundle {\\n pub kind: BundleKind,\\n pub id: ModuleId,\\n /// Merged module.\\n pub module: Module,\\n}\\n\\npub struct Bundler<\\'a, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n config: Config,\\n\\n globals: &\\'a Globals,\\n cm: Lrc,\\n loader: L,\\n resolver: R,\\n\\n _helper_ctxt: SyntaxContext,\\n /// Used to mark nodes as synthesized.\\n ///\\n /// We can check if a span is a dummy for now, but in future we may improve\\n /// spans.\\n synthesized_ctxt: SyntaxContext,\\n\\n /// Used to mark a variable declaration as injected.\\n pub(crate) injected_ctxt: SyntaxContext,\\n\\n scope: Scope,\\n\\n hook: Box,\\n}\\n\\nimpl<\\'a, L, R> Bundler<\\'a, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n pub fn new(\\n globals: &\\'a Globals,\\n cm: Lrc,\\n loader: L,\\n resolver: R,\\n config: Config,\\n hook: Box,\\n ) -> Self {\\n GLOBALS.set(&globals, || {\\n let helper_ctxt = SyntaxContext::empty().apply_mark(Mark::fresh(Mark::root()));\\n tracing::debug!(\"Helper ctxt: {:?}\", helper_ctxt);\\n let synthesized_ctxt = SyntaxContext::empty().apply_mark(Mark::fresh(Mark::root()));\\n tracing::debug!(\"Synthesized ctxt: {:?}\", synthesized_ctxt);\\n let injected_ctxt = SyntaxContext::empty().apply_mark(Mark::fresh(Mark::root()));\\n tracing::debug!(\"Injected ctxt: {:?}\", injected_ctxt);\\n\\n Bundler {\\n config,\\n globals,\\n cm,\\n loader,\\n resolver,\\n _helper_ctxt: helper_ctxt,\\n synthesized_ctxt,\\n injected_ctxt,\\n scope: Default::default(),\\n hook,\\n }\\n })\\n }\\n\\n ///\\n ///\\n ///\\n /// Note: This method will panic if entries references each other in\\n /// circular manner. However, it applies only to the provided `entries`, and\\n /// dependencies with circular reference is ok.\\n pub fn bundle(&self, entries: HashMap) -> Result, Error> {\\n let results = entries\\n .into_iter()\\n .map(|(name, path)| -> Result<_, Error> {\\n let path = match path {\\n FileName::Real(path) => {\\n if cfg!(target_os = \"windows\") {\\n let path = path\\n .canonicalize()\\n .context(\"failed to canonicalize entry\")?;\\n FileName::Real(path)\\n } else {\\n FileName::Real(path)\\n }\\n }\\n _ => path,\\n };\\n\\n let res = self\\n .load_transformed(&path)\\n .context(\"load_transformed failed\")?;\\n Ok((name, res))\\n })\\n .collect::>();\\n\\n // We collect at here to handle dynamic imports\\n // TODO: Handle dynamic imports\\n\\n let local = {\\n let mut output = AHashMap::default();\\n\\n for res in results {\\n let (name, m) = res?;\\n let m = m.unwrap();\\n\\n output.insert(name, m);\\n }\\n\\n output\\n };\\n\\n let bundles = self.chunk(local)?;\\n\\n let bundles = self.finalize(bundles)?;\\n Ok(bundles)\\n }\\n\\n /// Sets `swc_common::GLOBALS`\\n #[inline]\\n fn run(&self, op: F) -> Ret\\n where\\n F: FnOnce() -> Ret,\\n {\\n GLOBALS.set(self.globals, op)\\n }\\n}\\n',\n", + " 'content_id': '58b2db349c76ce427eec6ab7939f85d53ec9af20',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/bundler/src/bundler/mod.rs',\n", + " 'size': 5091,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6050145348837209,\n", + " 'avg_line_length': 22.65616045845272,\n", + " 'blob_id': 'ac5de54c88fd283887152469366ffa5e4b8d1934',\n", + " 'content': 'use regex::Regex;\\nuse rustc_hash::FxHashMap;\\nuse serde::{Deserialize, Serialize};\\nuse swc_atoms::JsWord;\\nuse swc_common::Mark;\\nuse swc_ecma_ast::{EsVersion, Expr};\\n\\npub mod terser;\\n\\n/// This is not serializable.\\n#[derive(Debug)]\\npub struct ExtraOptions {\\n /// The [Mark] used for `resolver_with_mark`.\\n pub top_level_mark: Mark,\\n}\\n\\n#[derive(Debug, Serialize, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\n#[serde(deny_unknown_fields)]\\npub struct MinifyOptions {\\n #[serde(default)]\\n pub rename: bool,\\n #[serde(default)]\\n pub compress: Option,\\n #[serde(default)]\\n pub mangle: Option,\\n #[serde(default)]\\n pub wrap: bool,\\n #[serde(default)]\\n pub enclose: bool,\\n}\\n\\n#[derive(Debug, Clone, Copy, Serialize, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\n#[serde(deny_unknown_fields)]\\npub struct TopLevelOptions {\\n pub functions: bool,\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\n#[serde(deny_unknown_fields)]\\npub struct MangleOptions {\\n #[serde(default, alias = \"properties\")]\\n pub props: Option,\\n\\n #[serde(default, alias = \"toplevel\")]\\n pub top_level: bool,\\n\\n #[serde(default, alias = \"keep_classnames\")]\\n pub keep_class_names: bool,\\n\\n #[serde(default, alias = \"keep_fnames\")]\\n pub keep_fn_names: bool,\\n\\n #[serde(default, alias = \"keep_private_props\")]\\n pub keep_private_props: bool,\\n\\n #[serde(default, alias = \"ie8\")]\\n pub ie8: bool,\\n\\n #[serde(default, alias = \"safari10\")]\\n pub safari10: bool,\\n}\\n\\n#[derive(Debug, Clone, Default, Serialize, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\npub struct ManglePropertiesOptions {\\n #[serde(default, alias = \"reserved\")]\\n pub reserved: Vec,\\n #[serde(default, alias = \"undeclared\")]\\n pub undeclared: bool,\\n #[serde(default, with = \"serde_regex\")]\\n pub regex: Option,\\n}\\n\\n#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\n#[serde(untagged)]\\npub enum PureGetterOption {\\n Bool(bool),\\n #[serde(rename = \"strict\")]\\n Strict,\\n Str(Vec),\\n}\\n\\nimpl Default for PureGetterOption {\\n fn default() -> Self {\\n Self::Strict\\n }\\n}\\n\\n/// https://terser.org/docs/api-reference.html#compress-options\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\n#[serde(deny_unknown_fields)]\\npub struct CompressOptions {\\n #[serde(default)]\\n #[serde(alias = \"arguments\")]\\n pub arguments: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n pub arrows: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"booleans\")]\\n pub bools: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"booleans_as_integers\")]\\n pub bools_as_ints: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"collapse_vars\")]\\n pub collapse_vars: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"comparisons\")]\\n pub comparisons: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"computed_props\")]\\n pub computed_props: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"conditionals\")]\\n pub conditionals: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"dead_code\")]\\n pub dead_code: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"directives\")]\\n pub directives: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"drop_console\")]\\n pub drop_console: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"drop_debugger\")]\\n pub drop_debugger: bool,\\n\\n #[serde(default = \"default_ecma\")]\\n pub ecma: EsVersion,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"evaluate\")]\\n pub evaluate: bool,\\n\\n /// Should we simplify expressions?\\n #[serde(default)]\\n #[serde(alias = \"expression\")]\\n pub expr: bool,\\n\\n /// All expressions should have dummy span. Use [swc_ecma_utils::drop_span]\\n /// to remove spans.\\n #[serde(skip)]\\n #[serde(alias = \"global_defs\")]\\n pub global_defs: FxHashMap, Box>,\\n\\n #[serde(default)]\\n #[serde(alias = \"hoist_funs\")]\\n pub hoist_fns: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"hoist_props\")]\\n pub hoist_props: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"hoist_vars\")]\\n pub hoist_vars: bool,\\n\\n /// No effect.\\n #[serde(default)]\\n #[serde(alias = \"ie8\")]\\n pub ie8: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"if_return\")]\\n pub if_return: bool,\\n\\n ///\\n /// - `0`: disabled inlining\\n /// - `1`: inline simple functions\\n /// - `2`: inline functions with arguments\\n /// - `3`: inline functions with arguments and variables\\n\\n #[serde(default = \"three_by_default\")]\\n #[serde(alias = \"inline\")]\\n pub inline: u8,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"join_vars\")]\\n pub join_vars: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"keep_classnames\")]\\n pub keep_classnames: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"keep_fargs\")]\\n pub keep_fargs: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"keep_fnames\")]\\n pub keep_fnames: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"keep_infinity\")]\\n pub keep_infinity: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"loops\")]\\n pub loops: bool,\\n // module : false,\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"negate_iife\")]\\n pub negate_iife: bool,\\n\\n /// If this value is zero, the minifier will repeat work until the ast node\\n /// is settled.\\n #[serde(default = \"one_by_default\")]\\n #[serde(alias = \"passes\")]\\n pub passes: usize,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"properties\")]\\n pub props: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"properties\")]\\n pub pure_getters: PureGetterOption,\\n\\n // pure_funcs : null,\\n #[serde(default)]\\n #[serde(alias = \"reduce_funcs\")]\\n pub reduce_fns: bool,\\n #[serde(default)]\\n #[serde(alias = \"reduce_vars\")]\\n pub reduce_vars: bool,\\n\\n #[serde(default = \"three_by_default\")]\\n #[serde(alias = \"sequences\")]\\n pub sequences: u8,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"side_effects\")]\\n pub side_effects: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"switches\")]\\n pub switches: bool,\\n\\n /// Top level symbols to retain.\\n #[serde(default)]\\n #[serde(alias = \"top_retain\")]\\n pub top_retain: Vec,\\n\\n #[serde(default)]\\n #[serde(alias = \"toplevel\")]\\n pub top_level: Option,\\n\\n #[serde(default = \"true_by_default\")]\\n #[serde(alias = \"typeofs\")]\\n pub typeofs: bool,\\n\\n #[serde(default)]\\n #[serde(rename = \"unsafe\")]\\n pub unsafe_passes: bool,\\n\\n #[serde(default)]\\n pub unsafe_arrows: bool,\\n\\n #[serde(default)]\\n pub unsafe_comps: bool,\\n\\n #[serde(default)]\\n #[serde(alias = \"unsafe_Function\")]\\n pub unsafe_function: bool,\\n\\n #[serde(default)]\\n pub unsafe_math: bool,\\n\\n #[serde(default)]\\n pub unsafe_symbols: bool,\\n\\n #[serde(default)]\\n pub unsafe_methods: bool,\\n\\n #[serde(default)]\\n pub unsafe_proto: bool,\\n\\n #[serde(default)]\\n pub unsafe_regexp: bool,\\n\\n #[serde(default)]\\n pub unsafe_undefined: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n pub unused: bool,\\n}\\n\\nimpl CompressOptions {\\n pub(crate) fn sequences(&self) -> bool {\\n self.sequences != 0\\n }\\n\\n /// Returns `true` if any of toplevel optimizer is enabled.\\n pub(crate) fn top_level(&self) -> bool {\\n if !self.top_retain.is_empty() {\\n return true;\\n }\\n\\n self.top_level.map(|v| v.functions).unwrap_or(false)\\n }\\n}\\n\\nconst fn true_by_default() -> bool {\\n true\\n}\\n\\nconst fn one_by_default() -> usize {\\n 1\\n}\\n\\nconst fn three_by_default() -> u8 {\\n 3\\n}\\n\\nconst fn default_ecma() -> EsVersion {\\n EsVersion::Es5\\n}\\n\\n/// Implement default using serde.\\nmacro_rules! impl_default {\\n ($T:ty) => {\\n impl Default for $T {\\n fn default() -> Self {\\n serde_json::from_str(\"{}\").unwrap()\\n }\\n }\\n };\\n}\\n\\nimpl_default!(MinifyOptions);\\nimpl_default!(MangleOptions);\\nimpl_default!(CompressOptions);\\n',\n", + " 'content_id': '8e216442b12fcf50ca242c64373f26d80c720bdb',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 79,\n", + " 'path': '/ecmascript/minifier/src/option/mod.rs',\n", + " 'size': 8256,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4274828549657099,\n", + " 'avg_line_length': 27.69533527696793,\n", + " 'blob_id': '4c1536712ed87da91fcb3ba83a0b74f0fdc140cc',\n", + " 'content': '#![allow(dead_code)]\\n\\nuse super::{Inlining, Phase};\\nuse indexmap::map::{Entry, IndexMap};\\nuse rustc_hash::{FxHashMap, FxHashSet, FxHasher};\\nuse std::{\\n borrow::Cow,\\n cell::{Cell, RefCell},\\n collections::VecDeque,\\n hash::BuildHasherDefault,\\n};\\nuse swc_atoms::js_word;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::ext::ExprRefExt;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\n\\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\\npub enum ScopeKind {\\n /// If / Switch\\n Cond,\\n Loop,\\n Block,\\n Fn {\\n named: bool,\\n },\\n}\\n\\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\\npub(super) enum VarType {\\n Param,\\n Var(VarDeclKind),\\n}\\n\\nimpl Default for ScopeKind {\\n fn default() -> Self {\\n Self::Fn { named: false }\\n }\\n}\\n\\nimpl Inlining<\\'_> {\\n pub(super) fn with_child(&mut self, kind: ScopeKind, op: F)\\n where\\n F: for<\\'any> FnOnce(&mut Inlining<\\'any>),\\n {\\n let (unresolved_usages, bindings) = {\\n let mut child = Inlining {\\n phase: self.phase,\\n is_first_run: self.is_first_run,\\n changed: false,\\n scope: Scope::new(Some(&self.scope), kind),\\n var_decl_kind: VarDeclKind::Var,\\n ident_type: self.ident_type,\\n pat_mode: self.pat_mode,\\n in_test: self.in_test,\\n };\\n\\n op(&mut child);\\n\\n self.changed |= child.changed;\\n\\n (child.scope.unresolved_usages, child.scope.bindings)\\n };\\n\\n tracing::trace!(\"propagating variables\");\\n\\n self.scope.unresolved_usages.extend(unresolved_usages);\\n\\n if match kind {\\n ScopeKind::Fn { .. } => false,\\n _ => true,\\n } {\\n let v = bindings;\\n\\n for (id, v) in v.into_iter().filter_map(|(id, v)| {\\n if v.kind == VarType::Var(VarDeclKind::Var) {\\n Some((id, v))\\n } else {\\n None\\n }\\n }) {\\n let v: VarInfo = v;\\n\\n tracing::trace!(\"Hoisting a variable {:?}\", id);\\n\\n if self.scope.unresolved_usages.contains(&id) {\\n v.inline_prevented.set(true)\\n }\\n\\n v.hoisted.set(true);\\n\\n *v.value.borrow_mut() = None;\\n v.is_undefined.set(false);\\n self.scope.bindings.insert(id, v);\\n }\\n }\\n }\\n\\n /// Note: this method stores the value only if init is [Cow::Owned] or it\\'s\\n /// [Expr::Ident] or [Expr::Lit].\\n pub(super) fn declare(\\n &mut self,\\n id: Id,\\n init: Option>,\\n is_change: bool,\\n kind: VarType,\\n ) {\\n tracing::trace!(\\n \"({}, {:?}) declare({})\",\\n self.scope.depth(),\\n self.phase,\\n id.0\\n );\\n\\n let init = init.map(|cow| match cow {\\n Cow::Owned(v) => Cow::Owned(v),\\n Cow::Borrowed(b) => match b {\\n Expr::Ident(..) | Expr::Lit(..) => Cow::Owned(b.clone()),\\n _ => Cow::Borrowed(b),\\n },\\n });\\n\\n let is_undefined = self.var_decl_kind == VarDeclKind::Var\\n && !is_change\\n && init.is_none()\\n && self.phase == Phase::Inlining;\\n\\n let mut alias_of = None;\\n\\n let value_idx = match init.as_ref().map(|v| &**v) {\\n Some(&Expr::Ident(ref vi)) => {\\n if let Some((value_idx, value_var)) = self.scope.idx_val(&vi.to_id()) {\\n alias_of = Some(value_var.kind);\\n Some((value_idx, vi.to_id()))\\n } else {\\n None\\n }\\n }\\n _ => None,\\n };\\n\\n let is_inline_prevented = self.scope.should_prevent_inline_because_of_scope(&id)\\n || match init {\\n Some(ref e) => self.scope.is_inline_prevented(&e),\\n _ => false,\\n };\\n\\n if is_inline_prevented {\\n tracing::trace!(\"\\\\tdeclare: Inline prevented: {:?}\", id)\\n }\\n if is_undefined {\\n tracing::trace!(\"\\\\tdeclare: {:?} is undefined\", id);\\n }\\n\\n let idx = match self.scope.bindings.entry(id.clone()) {\\n Entry::Occupied(mut e) => {\\n e.get().is_undefined.set(is_undefined);\\n e.get().read_cnt.set(0);\\n e.get().read_from_nested_scope.set(false);\\n\\n match init {\\n Some(Cow::Owned(v)) => e.get_mut().value = RefCell::new(Some(v)),\\n None => e.get_mut().value = RefCell::new(None),\\n _ => {}\\n }\\n\\n e.get().inline_prevented.set(is_inline_prevented);\\n e.index()\\n }\\n Entry::Vacant(e) => {\\n let idx = e.index();\\n e.insert(VarInfo {\\n kind,\\n alias_of,\\n read_from_nested_scope: Cell::new(false),\\n read_cnt: Cell::new(0),\\n inline_prevented: Cell::new(is_inline_prevented),\\n is_undefined: Cell::new(is_undefined),\\n value: RefCell::new(match init {\\n Some(Cow::Owned(v)) => Some(v),\\n _ => None,\\n }),\\n this_sensitive: Cell::new(false),\\n hoisted: Cell::new(false),\\n });\\n idx\\n }\\n };\\n\\n {\\n let mut cur = Some(&self.scope);\\n while let Some(scope) = cur {\\n if let ScopeKind::Fn { .. } = scope.kind {\\n break;\\n }\\n\\n if scope.kind == ScopeKind::Loop {\\n tracing::trace!(\"preventing inline as it\\'s declared in a loop\");\\n self.scope.prevent_inline(&id);\\n break;\\n }\\n\\n cur = scope.parent;\\n }\\n }\\n\\n //\\n let barrier_works = match kind {\\n VarType::Param => false,\\n _ if alias_of == Some(VarType::Param) => false,\\n _ => true,\\n };\\n\\n if barrier_works {\\n if let Some((value_idx, vi)) = value_idx {\\n tracing::trace!(\"\\\\tdeclare: {} -> {}\", idx, value_idx);\\n\\n let barrier_exists = (|| {\\n for &blocker in self.scope.inline_barriers.borrow().iter() {\\n if value_idx <= blocker && blocker <= idx {\\n return true;\\n } else if idx <= blocker && blocker <= value_idx {\\n return true;\\n }\\n }\\n\\n false\\n })();\\n\\n if value_idx > idx || barrier_exists {\\n tracing::trace!(\"Variable use before declaration: {:?}\", id);\\n self.scope.prevent_inline(&id);\\n self.scope.prevent_inline(&vi)\\n }\\n } else {\\n tracing::trace!(\"\\\\tdeclare: value idx is none\");\\n }\\n }\\n }\\n}\\n\\n#[derive(Debug, Default)]\\npub(super) struct Scope<\\'a> {\\n pub parent: Option<&\\'a Scope<\\'a>>,\\n pub kind: ScopeKind,\\n\\n inline_barriers: RefCell>,\\n bindings: IndexMap>,\\n unresolved_usages: FxHashSet,\\n\\n /// Simple optimization. We don\\'t need complex scope analysis.\\n pub constants: FxHashMap>,\\n}\\n\\nimpl<\\'a> Scope<\\'a> {\\n pub fn new(parent: Option<&\\'a Scope<\\'a>>, kind: ScopeKind) -> Self {\\n Self {\\n parent,\\n kind,\\n ..Default::default()\\n }\\n }\\n\\n pub fn depth(&self) -> usize {\\n match self.parent {\\n None => 0,\\n Some(p) => p.depth() + 1,\\n }\\n }\\n\\n fn should_prevent_inline_because_of_scope(&self, id: &Id) -> bool {\\n if self.unresolved_usages.contains(id) {\\n return true;\\n }\\n\\n match self.parent {\\n None => false,\\n Some(p) => {\\n if p.should_prevent_inline_because_of_scope(id) {\\n return true;\\n }\\n\\n if let Some(v) = p.find_binding(id) {\\n if v.hoisted.get() && v.is_inline_prevented() {\\n return true;\\n }\\n }\\n\\n false\\n }\\n }\\n }\\n\\n /// True if the returned scope is self\\n fn scope_for(&self, id: &Id) -> (&Scope, bool) {\\n if let Some(..) = self.constants.get(id) {\\n return (self, true);\\n }\\n if let Some(..) = self.find_binding_from_current(id) {\\n return (self, true);\\n }\\n\\n match self.parent {\\n None => (self, true),\\n Some(ref p) => {\\n let (s, _) = p.scope_for(id);\\n (s, false)\\n }\\n }\\n }\\n\\n pub fn read_cnt(&self, id: &Id) -> Option {\\n if let Some(var) = self.find_binding(id) {\\n return Some(var.read_cnt.get());\\n }\\n\\n None\\n }\\n\\n fn read_prevents_inlining(&self, id: &Id) -> bool {\\n tracing::trace!(\"read_prevents_inlining({:?})\", id);\\n\\n if let Some(v) = self.find_binding(id) {\\n match v.kind {\\n // Reading parameter is ok.\\n VarType::Param => return false,\\n VarType::Var(VarDeclKind::Let) | VarType::Var(VarDeclKind::Const) => return false,\\n _ => {}\\n }\\n\\n // If it\\'s already hoisted, it means that it is already processed by child\\n // scope.\\n if v.hoisted.get() {\\n return false;\\n }\\n }\\n\\n {\\n let mut cur = Some(self);\\n\\n while let Some(scope) = cur {\\n let found = scope.find_binding_from_current(id).is_some();\\n\\n if found {\\n tracing::trace!(\"found\");\\n break;\\n }\\n tracing::trace!(\"({}): {}: kind = {:?}\", scope.depth(), id.0, scope.kind);\\n\\n match scope.kind {\\n ScopeKind::Fn { .. } => {\\n tracing::trace!(\\n \"{}: variable access from a nested function detected\",\\n id.0\\n );\\n return true;\\n }\\n ScopeKind::Loop | ScopeKind::Cond => {\\n return true;\\n }\\n _ => {}\\n }\\n cur = scope.parent;\\n }\\n }\\n\\n false\\n }\\n\\n pub fn add_read(&mut self, id: &Id) {\\n if self.read_prevents_inlining(id) {\\n tracing::trace!(\"prevent inlining because of read: {}\", id.0);\\n\\n self.prevent_inline(id)\\n }\\n\\n if id.0 == js_word!(\"arguments\") {\\n self.prevent_inline_of_params();\\n }\\n\\n if let Some(var_info) = self.find_binding(id) {\\n var_info.read_cnt.set(var_info.read_cnt.get() + 1);\\n if var_info.hoisted.get() {\\n var_info.inline_prevented.set(true);\\n }\\n } else {\\n tracing::trace!(\"({}): Unresolved usage.: {:?}\", self.depth(), id);\\n self.unresolved_usages.insert(id.clone());\\n }\\n\\n let (scope, is_self) = self.scope_for(id);\\n if !is_self {\\n if let Some(var_info) = scope.find_binding_from_current(id) {\\n var_info.read_from_nested_scope.set(true);\\n }\\n }\\n }\\n\\n fn write_prevents_inline(&self, id: &Id) -> bool {\\n tracing::trace!(\"write_prevents_inline({})\", id.0);\\n\\n {\\n let mut cur = Some(self);\\n\\n while let Some(scope) = cur {\\n let found = scope.find_binding_from_current(id).is_some();\\n\\n if found {\\n break;\\n }\\n tracing::trace!(\"({}): {}: kind = {:?}\", scope.depth(), id.0, scope.kind);\\n\\n match scope.kind {\\n ScopeKind::Fn { .. } => {\\n tracing::trace!(\\n \"{}: variable access from a nested function detected\",\\n id.0\\n );\\n return true;\\n }\\n ScopeKind::Loop | ScopeKind::Cond => {\\n return true;\\n }\\n _ => {}\\n }\\n cur = scope.parent;\\n }\\n }\\n\\n false\\n }\\n\\n pub fn add_write(&mut self, id: &Id, force_no_inline: bool) {\\n if self.write_prevents_inline(id) {\\n tracing::trace!(\"prevent inlining because of write: {}\", id.0);\\n\\n self.prevent_inline(id)\\n }\\n\\n if id.0 == js_word!(\"arguments\") {\\n self.prevent_inline_of_params();\\n }\\n\\n let (scope, is_self) = self.scope_for(id);\\n\\n if let Some(var_info) = scope.find_binding_from_current(id) {\\n var_info.is_undefined.set(false);\\n\\n if !is_self || force_no_inline {\\n self.prevent_inline(id)\\n }\\n } else if self.has_constant(id) {\\n // noop\\n } else {\\n tracing::trace!(\\n \"({}): Unresolved. (scope = ({})): {:?}\",\\n self.depth(),\\n scope.depth(),\\n id\\n );\\n self.bindings.insert(\\n id.clone(),\\n VarInfo {\\n kind: VarType::Var(VarDeclKind::Var),\\n alias_of: None,\\n read_from_nested_scope: Cell::new(false),\\n read_cnt: Cell::new(0),\\n inline_prevented: Cell::new(force_no_inline),\\n value: RefCell::new(None),\\n is_undefined: Cell::new(false),\\n this_sensitive: Cell::new(false),\\n hoisted: Cell::new(false),\\n },\\n );\\n }\\n }\\n\\n pub fn find_binding(&self, id: &Id) -> Option<&VarInfo> {\\n if let Some(e) = self.find_binding_from_current(id) {\\n return Some(e);\\n }\\n\\n self.parent.and_then(|parent| parent.find_binding(id))\\n }\\n\\n /// Searches only for current scope.\\n fn idx_val(&self, id: &Id) -> Option<(usize, &VarInfo)> {\\n self.bindings.iter().enumerate().find_map(\\n |(idx, (k, v))| {\\n if k == id {\\n Some((idx, v))\\n } else {\\n None\\n }\\n },\\n )\\n }\\n\\n pub fn find_binding_from_current(&self, id: &Id) -> Option<&VarInfo> {\\n let (_, v) = self.idx_val(id)?;\\n\\n Some(v)\\n }\\n\\n fn has_constant(&self, id: &Id) -> bool {\\n if let Some(..) = self.constants.get(id) {\\n return true;\\n }\\n\\n self.parent\\n .map(|parent| parent.has_constant(id))\\n .unwrap_or(false)\\n }\\n\\n pub fn find_constant(&self, id: &Id) -> Option<&Expr> {\\n if let Some(Some(e)) = self.constants.get(id) {\\n return Some(e);\\n }\\n\\n self.parent.and_then(|parent| parent.find_constant(id))\\n }\\n\\n pub fn mark_this_sensitive(&self, callee: &Expr) {\\n match callee {\\n Expr::Ident(ref i) => {\\n if let Some(v) = self.find_binding(&i.to_id()) {\\n v.this_sensitive.set(true);\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n pub fn store_inline_barrier(&self, phase: Phase) {\\n tracing::trace!(\"store_inline_barrier({:?})\", phase);\\n\\n match phase {\\n Phase::Analysis => {\\n let idx = self.bindings.len();\\n self.inline_barriers.borrow_mut().push_back(idx);\\n }\\n Phase::Inlining => {\\n //if let Some(idx) =\\n // self.inline_barriers.borrow_mut().pop_front() {\\n // for i in 0..idx {\\n // if let Some((id, _)) = self.bindings.get_index(i) {\\n // self.prevent_inline(id);\\n // }\\n // }\\n //}\\n }\\n }\\n\\n match self.parent {\\n None => {}\\n Some(p) => p.store_inline_barrier(phase),\\n }\\n }\\n\\n fn prevent_inline_of_params(&self) {\\n for (_, v) in self.bindings.iter() {\\n let v: &VarInfo = v;\\n\\n if v.is_param() {\\n v.inline_prevented.set(true);\\n }\\n }\\n\\n if let ScopeKind::Fn { .. } = self.kind {\\n return;\\n }\\n\\n match self.parent {\\n Some(p) => p.prevent_inline_of_params(),\\n None => {}\\n }\\n }\\n\\n pub fn prevent_inline(&self, id: &Id) {\\n tracing::trace!(\"({}) Prevent inlining: {:?}\", self.depth(), id);\\n\\n if let Some(v) = self.find_binding_from_current(id) {\\n v.inline_prevented.set(true);\\n }\\n\\n for (_, v) in self.bindings.iter() {\\n match v.value.borrow().as_ref() {\\n Some(&Expr::Ident(ref i)) => {\\n if i.sym == id.0 && i.span.ctxt() == id.1 {\\n v.inline_prevented.set(true);\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n match self.parent {\\n None => {}\\n Some(p) => p.prevent_inline(id),\\n }\\n }\\n\\n pub fn is_inline_prevented(&self, e: &Expr) -> bool {\\n match &*e {\\n Expr::Ident(ref ri) => {\\n if let Some(v) = self.find_binding_from_current(&ri.to_id()) {\\n return v.inline_prevented.get();\\n }\\n }\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(right_expr),\\n ..\\n }) if right_expr.is_ident() => {\\n let ri = right_expr.as_ident().unwrap();\\n\\n if let Some(v) = self.find_binding_from_current(&ri.to_id()) {\\n return v.inline_prevented.get();\\n }\\n }\\n Expr::Update(..) => return true,\\n\\n // TODO: Remove this\\n Expr::Paren(..) | Expr::Call(..) | Expr::New(..) => return true,\\n\\n _ => {}\\n }\\n\\n match self.parent {\\n None => false,\\n Some(p) => p.is_inline_prevented(e),\\n }\\n }\\n\\n pub fn has_same_this(&self, id: &Id, init: Option<&Expr>) -> bool {\\n if let Some(v) = self.find_binding(id) {\\n if v.this_sensitive.get() {\\n match init {\\n Some(&Expr::Member(..)) => return false,\\n _ => {}\\n }\\n }\\n }\\n\\n true\\n }\\n}\\n\\n#[derive(Debug)]\\npub(super) struct VarInfo {\\n pub kind: VarType,\\n\\n alias_of: Option,\\n\\n read_from_nested_scope: Cell,\\n read_cnt: Cell,\\n\\n inline_prevented: Cell,\\n this_sensitive: Cell,\\n\\n pub value: RefCell>,\\n pub is_undefined: Cell,\\n\\n hoisted: Cell,\\n}\\n\\nimpl VarInfo {\\n pub fn is_param(&self) -> bool {\\n self.kind == VarType::Param\\n }\\n\\n pub fn is_inline_prevented(&self) -> bool {\\n if self.inline_prevented.get() {\\n return true;\\n }\\n\\n if self.this_sensitive.get() {\\n match *self.value.borrow() {\\n Some(Expr::Member(..)) => return true,\\n _ => {}\\n }\\n }\\n\\n false\\n }\\n}\\n',\n", + " 'content_id': 'c5f9c4489ffb41cffdee760cc1f86d1abd188219',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/ecmascript/transforms/optimization/src/simplify/inlining/scope.rs',\n", + " 'size': 19685,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.7040229885057471,\n", + " 'avg_line_length': 33.8,\n", + " 'blob_id': '38b6195722d141d7ab2238c0cec93b6133f35915',\n", + " 'content': '//! Ported from https://github.com/zloirock/core-js/tree/master/packages/core-js-compat\\n\\nuse crate::Versions;\\nuse once_cell::sync::Lazy;\\nuse rustc_hash::FxHashMap;\\n\\npub static DATA: Lazy> = Lazy::new(|| {\\n serde_json::from_str(include_str!(\"compat.json\"))\\n .expect(\"failed parse corejs3-compat data.json\")\\n});\\n',\n", + " 'content_id': 'd0c7bbcd5fdc74f5e8d967e487516623ff016a5d',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 87,\n", + " 'path': '/ecmascript/preset-env/src/corejs3/compat.rs',\n", + " 'size': 348,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5037077229155362,\n", + " 'avg_line_length': 29.04891304347826,\n", + " 'blob_id': '9eb14dbeee300f1b3e5efeca05f23e5284321f54',\n", + " 'content': '//! Compatibility for terser config.\\n\\nuse super::{true_by_default, CompressOptions, TopLevelOptions};\\nuse crate::option::PureGetterOption;\\nuse rustc_hash::FxHashMap;\\nuse serde::{Deserialize, Serialize};\\nuse serde_json::Value;\\nuse swc_atoms::JsWord;\\nuse swc_common::{input::SourceFileInput, sync::Lrc, FileName, SourceMap, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_parser::{lexer::Lexer, Parser};\\nuse swc_ecma_utils::drop_span;\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\n#[serde(untagged)]\\npub enum TerserEcmaVersion {\\n Num(usize),\\n Str(String),\\n}\\n\\nimpl Default for TerserEcmaVersion {\\n fn default() -> Self {\\n Self::Num(5)\\n }\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\n#[serde(untagged)]\\npub enum TerserPureGetterOption {\\n Bool(bool),\\n #[serde(rename = \"strict\")]\\n Strict,\\n Str(String),\\n}\\n\\nimpl Default for TerserPureGetterOption {\\n fn default() -> Self {\\n TerserPureGetterOption::Strict\\n }\\n}\\n\\n#[derive(Debug, Clone, Copy, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\n#[serde(untagged)]\\npub enum TerserInlineOption {\\n Bool(bool),\\n Num(u8),\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\n#[serde(untagged)]\\npub enum TerserTopLevelOptions {\\n Bool(bool),\\n Str(String),\\n}\\n\\n#[derive(Debug, Clone, Copy, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\n#[serde(untagged)]\\npub enum TerserSequenceOptions {\\n Bool(bool),\\n Num(u8),\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\n#[serde(untagged)]\\npub enum TerserTopRetainOption {\\n Str(String),\\n Seq(Vec),\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields)]\\npub struct TerserCompressorOptions {\\n #[serde(default)]\\n pub arguments: bool,\\n\\n #[serde(default)]\\n pub arrows: Option,\\n\\n #[serde(default)]\\n pub booleans: Option,\\n\\n #[serde(default)]\\n pub booleans_as_integers: bool,\\n\\n #[serde(default)]\\n pub collapse_vars: Option,\\n\\n #[serde(default)]\\n pub comparisons: Option,\\n\\n #[serde(default)]\\n pub computed_props: bool,\\n\\n #[serde(default)]\\n pub conditionals: bool,\\n\\n #[serde(default)]\\n pub dead_code: bool,\\n\\n #[serde(default = \"true_by_default\")]\\n pub defaults: bool,\\n\\n #[serde(default)]\\n pub directives: bool,\\n\\n #[serde(default)]\\n pub drop_console: bool,\\n\\n #[serde(default)]\\n pub drop_debugger: Option,\\n\\n #[serde(default = \"ecma_default\")]\\n pub ecma: TerserEcmaVersion,\\n\\n #[serde(default)]\\n pub evaluate: Option,\\n\\n #[serde(default)]\\n pub expression: bool,\\n\\n #[serde(default)]\\n pub global_defs: FxHashMap,\\n\\n #[serde(default)]\\n pub hoist_funs: bool,\\n\\n #[serde(default)]\\n pub hoist_props: Option,\\n\\n #[serde(default)]\\n pub hoist_vars: bool,\\n\\n #[serde(default)]\\n pub ie8: bool,\\n\\n #[serde(default)]\\n pub if_return: Option,\\n\\n #[serde(default)]\\n pub inline: Option,\\n\\n #[serde(default)]\\n pub join_vars: Option,\\n\\n #[serde(default)]\\n pub keep_classnames: bool,\\n\\n #[serde(default)]\\n pub keep_fargs: Option,\\n\\n #[serde(default)]\\n pub keep_fnames: bool,\\n\\n #[serde(default)]\\n pub keep_infinity: bool,\\n\\n #[serde(default)]\\n pub loops: Option,\\n // module : false,\\n #[serde(default)]\\n pub negate_iife: Option,\\n\\n #[serde(default)]\\n pub passes: usize,\\n\\n #[serde(default)]\\n pub properties: Option,\\n\\n #[serde(default)]\\n pub pure_getters: TerserPureGetterOption,\\n\\n #[serde(default)]\\n pub pure_funcs: Vec,\\n\\n #[serde(default)]\\n pub reduce_funcs: bool,\\n\\n #[serde(default)]\\n pub reduce_vars: bool,\\n\\n #[serde(default)]\\n pub sequences: Option,\\n\\n #[serde(default)]\\n pub side_effects: Option,\\n\\n #[serde(default)]\\n pub switches: bool,\\n\\n #[serde(default)]\\n pub top_retain: Option,\\n\\n #[serde(default)]\\n pub toplevel: Option,\\n\\n #[serde(default)]\\n pub typeofs: Option,\\n\\n #[serde(default)]\\n #[serde(rename = \"unsafe\")]\\n pub unsafe_passes: bool,\\n\\n #[serde(default)]\\n pub unsafe_arrows: bool,\\n\\n #[serde(default)]\\n pub unsafe_comps: bool,\\n\\n #[serde(default)]\\n #[serde(rename = \"unsafe_Function\")]\\n pub unsafe_function: bool,\\n\\n #[serde(default)]\\n pub unsafe_math: bool,\\n\\n #[serde(default)]\\n pub unsafe_symbols: bool,\\n\\n #[serde(default)]\\n pub unsafe_methods: bool,\\n\\n #[serde(default)]\\n pub unsafe_proto: bool,\\n\\n #[serde(default)]\\n pub unsafe_regexp: bool,\\n\\n #[serde(default)]\\n pub unsafe_undefined: bool,\\n\\n #[serde(default)]\\n pub unused: Option,\\n\\n #[serde(default)]\\n pub module: bool,\\n}\\n\\nimpl Default for TerserCompressorOptions {\\n fn default() -> Self {\\n Self {\\n arguments: Default::default(),\\n arrows: Default::default(),\\n booleans: Default::default(),\\n booleans_as_integers: Default::default(),\\n collapse_vars: Default::default(),\\n comparisons: Default::default(),\\n computed_props: Default::default(),\\n conditionals: Default::default(),\\n dead_code: Default::default(),\\n defaults: true,\\n directives: Default::default(),\\n drop_console: Default::default(),\\n drop_debugger: Default::default(),\\n ecma: Default::default(),\\n evaluate: Default::default(),\\n expression: Default::default(),\\n global_defs: Default::default(),\\n hoist_funs: Default::default(),\\n hoist_props: Default::default(),\\n hoist_vars: Default::default(),\\n ie8: Default::default(),\\n if_return: Default::default(),\\n inline: Default::default(),\\n join_vars: Default::default(),\\n keep_classnames: Default::default(),\\n keep_fargs: Default::default(),\\n keep_fnames: Default::default(),\\n keep_infinity: Default::default(),\\n loops: Default::default(),\\n negate_iife: Default::default(),\\n passes: Default::default(),\\n properties: Default::default(),\\n pure_getters: Default::default(),\\n pure_funcs: Default::default(),\\n reduce_funcs: Default::default(),\\n reduce_vars: Default::default(),\\n sequences: Default::default(),\\n side_effects: Default::default(),\\n switches: Default::default(),\\n top_retain: Default::default(),\\n toplevel: Default::default(),\\n typeofs: Default::default(),\\n unsafe_passes: Default::default(),\\n unsafe_arrows: Default::default(),\\n unsafe_comps: Default::default(),\\n unsafe_function: Default::default(),\\n unsafe_math: Default::default(),\\n unsafe_symbols: Default::default(),\\n unsafe_methods: Default::default(),\\n unsafe_proto: Default::default(),\\n unsafe_regexp: Default::default(),\\n unsafe_undefined: Default::default(),\\n unused: Default::default(),\\n module: Default::default(),\\n }\\n }\\n}\\n\\nfn ecma_default() -> TerserEcmaVersion {\\n TerserEcmaVersion::Num(5)\\n}\\n\\nimpl TerserCompressorOptions {\\n pub fn into_config(self, cm: Lrc) -> CompressOptions {\\n CompressOptions {\\n arguments: self.arguments,\\n arrows: self.arrows.unwrap_or(self.defaults),\\n bools: self.booleans.unwrap_or(self.defaults),\\n bools_as_ints: self.booleans_as_integers,\\n collapse_vars: self.collapse_vars.unwrap_or(self.defaults),\\n comparisons: self.comparisons.unwrap_or(self.defaults),\\n computed_props: self.computed_props,\\n conditionals: self.conditionals,\\n dead_code: self.dead_code,\\n directives: self.directives,\\n drop_console: self.drop_console,\\n drop_debugger: self.drop_debugger.unwrap_or(self.defaults),\\n ecma: self.ecma.into(),\\n evaluate: self.evaluate.unwrap_or(self.defaults),\\n expr: self.expression,\\n global_defs: self\\n .global_defs\\n .into_iter()\\n .map(|(k, v)| {\\n let parse = |input: String| {\\n let fm = cm.new_source_file(FileName::Anon, input);\\n\\n let lexer = Lexer::new(\\n Default::default(),\\n Default::default(),\\n SourceFileInput::from(&*fm),\\n None,\\n );\\n let mut parser = Parser::new_from(lexer);\\n\\n parser.parse_expr().map(drop_span).unwrap_or_else(|err| {\\n panic!(\\n \"failed to parse `global_defs.{}` of minifier options: {:?}\",\\n k, err\\n )\\n })\\n };\\n let key = parse(if k.starts_with(\\'@\\') {\\n k[1..].to_string()\\n } else {\\n k.to_string()\\n });\\n\\n (\\n key,\\n if k.starts_with(\\'@\\') {\\n parse(\\n v.as_str()\\n .unwrap_or_else(|| {\\n panic!(\\n \"Value of `global_defs.{}` must be a string literal: \",\\n k\\n )\\n })\\n .into(),\\n )\\n } else {\\n value_to_expr(v)\\n },\\n )\\n })\\n .collect(),\\n hoist_fns: self.hoist_funs,\\n hoist_props: self.hoist_props.unwrap_or(self.defaults),\\n hoist_vars: self.hoist_vars,\\n ie8: self.ie8,\\n if_return: self.if_return.unwrap_or(self.defaults),\\n inline: self\\n .inline\\n .map(|v| match v {\\n TerserInlineOption::Bool(v) => {\\n if v {\\n 3\\n } else {\\n 0\\n }\\n }\\n TerserInlineOption::Num(n) => n,\\n })\\n .unwrap_or(if self.defaults { 3 } else { 0 }),\\n join_vars: self.join_vars.unwrap_or(self.defaults),\\n keep_classnames: self.keep_classnames,\\n keep_fargs: self.keep_fargs.unwrap_or(self.defaults),\\n keep_fnames: self.keep_fnames,\\n keep_infinity: self.keep_infinity,\\n loops: self.loops.unwrap_or(self.defaults),\\n negate_iife: self.negate_iife.unwrap_or(self.defaults),\\n passes: self.passes,\\n props: self.properties.unwrap_or(self.defaults),\\n pure_getters: match self.pure_getters {\\n TerserPureGetterOption::Bool(v) => PureGetterOption::Bool(v),\\n TerserPureGetterOption::Strict => PureGetterOption::Strict,\\n TerserPureGetterOption::Str(v) => {\\n PureGetterOption::Str(v.split(\\',\\').map(From::from).collect())\\n }\\n },\\n reduce_fns: self.reduce_funcs,\\n reduce_vars: self.reduce_vars,\\n sequences: self\\n .sequences\\n .map(|v| match v {\\n TerserSequenceOptions::Bool(v) => {\\n if v {\\n 3\\n } else {\\n 0\\n }\\n }\\n TerserSequenceOptions::Num(v) => v,\\n })\\n .unwrap_or(if self.defaults { 3 } else { 0 }),\\n side_effects: self.side_effects.unwrap_or(self.defaults),\\n switches: self.switches,\\n top_retain: self.top_retain.map(From::from).unwrap_or_default(),\\n top_level: self.toplevel.map(From::from),\\n typeofs: self.typeofs.unwrap_or(self.defaults),\\n unsafe_passes: self.unsafe_passes,\\n unsafe_arrows: self.unsafe_arrows,\\n unsafe_comps: self.unsafe_comps,\\n unsafe_function: self.unsafe_function,\\n unsafe_math: self.unsafe_math,\\n unsafe_symbols: self.unsafe_symbols,\\n unsafe_methods: self.unsafe_methods,\\n unsafe_proto: self.unsafe_proto,\\n unsafe_regexp: self.unsafe_regexp,\\n unsafe_undefined: self.unsafe_undefined,\\n unused: self.unused.unwrap_or(self.defaults),\\n }\\n }\\n}\\n\\nimpl From for TopLevelOptions {\\n fn from(c: TerserTopLevelOptions) -> Self {\\n match c {\\n TerserTopLevelOptions::Bool(v) => TopLevelOptions { functions: v },\\n TerserTopLevelOptions::Str(..) => {\\n // TODO\\n TopLevelOptions { functions: false }\\n }\\n }\\n }\\n}\\n\\nimpl From for EsVersion {\\n fn from(v: TerserEcmaVersion) -> Self {\\n match v {\\n TerserEcmaVersion::Num(v) => match v {\\n 3 => EsVersion::Es3,\\n 5 => EsVersion::Es5,\\n 6 | 2015 => EsVersion::Es2015,\\n 2016 => EsVersion::Es2016,\\n 2017 => EsVersion::Es2017,\\n 2018 => EsVersion::Es2018,\\n 2019 => EsVersion::Es2019,\\n 2020 => EsVersion::Es2020,\\n _ => {\\n panic!(\"`{}` is not a valid ecmascript version\", v)\\n }\\n },\\n TerserEcmaVersion::Str(v) => {\\n TerserEcmaVersion::Num(v.parse().expect(\"failed to parse version of ecmascript\"))\\n .into()\\n }\\n }\\n }\\n}\\n\\nimpl From for Vec {\\n fn from(v: TerserTopRetainOption) -> Self {\\n match v {\\n TerserTopRetainOption::Str(s) => s\\n .split(\",\")\\n .filter(|s| s.trim() != \"\")\\n .map(|v| v.into())\\n .collect(),\\n TerserTopRetainOption::Seq(v) => v,\\n }\\n }\\n}\\n\\nfn value_to_expr(v: Value) -> Box {\\n match v {\\n Value::Null => Box::new(Expr::Lit(Lit::Null(Null { span: DUMMY_SP }))),\\n Value::Bool(value) => Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value,\\n }))),\\n Value::Number(v) => {\\n if cfg!(feature = \"debug\") {\\n tracing::debug!(\"Creating a numeric literal from value\");\\n }\\n\\n Box::new(Expr::Lit(Lit::Num(Number {\\n span: DUMMY_SP,\\n value: v.as_f64().unwrap(),\\n })))\\n }\\n Value::String(v) => Box::new(Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: v.into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n\\n Value::Array(arr) => {\\n let elems = arr\\n .into_iter()\\n .map(value_to_expr)\\n .map(|expr| Some(ExprOrSpread { spread: None, expr }))\\n .collect();\\n Box::new(Expr::Array(ArrayLit {\\n span: DUMMY_SP,\\n elems,\\n }))\\n }\\n\\n Value::Object(obj) => {\\n let props = obj\\n .into_iter()\\n .map(|(k, v)| (k, value_to_expr(v)))\\n .map(|(key, value)| KeyValueProp {\\n key: PropName::Str(Str {\\n span: DUMMY_SP,\\n value: key.into(),\\n has_escape: false,\\n kind: Default::default(),\\n }),\\n value,\\n })\\n .map(Prop::KeyValue)\\n .map(Box::new)\\n .map(PropOrSpread::Prop)\\n .collect();\\n\\n Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props,\\n }))\\n }\\n }\\n}\\n',\n", + " 'content_id': '2a1b0ceabe4fe8dd4d14fce2ffe763f57a2fed53',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/minifier/src/option/terser.rs',\n", + " 'size': 16587,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4254394627691092,\n", + " 'avg_line_length': 30.842767295597483,\n", + " 'blob_id': '7e256fba8bef2884001a0a6a8295755670638ce3',\n", + " 'content': \"use rustc_hash::FxHashMap;\\nuse swc_common::util::take::Take;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\n\\n/// This pass is kind of inliner, but it's far faster.\\npub fn constant_propagation() -> impl 'static + Fold + VisitMut {\\n as_folder(ConstPropagation::default())\\n}\\n\\n#[derive(Default)]\\nstruct ConstPropagation<'a> {\\n scope: Scope<'a>,\\n}\\n#[derive(Default)]\\nstruct Scope<'a> {\\n parent: Option<&'a Scope<'a>>,\\n /// Stores only inlinable constant variables.\\n vars: FxHashMap>,\\n}\\n\\nimpl<'a> Scope<'a> {\\n fn new(parent: &'a Scope<'a>) -> Self {\\n Self {\\n parent: Some(parent),\\n vars: Default::default(),\\n }\\n }\\n\\n fn find_var(&self, id: &Id) -> Option<&Box> {\\n if let Some(v) = self.vars.get(id) {\\n return Some(v);\\n }\\n\\n self.parent.and_then(|parent| parent.find_var(id))\\n }\\n}\\n\\nimpl VisitMut for ConstPropagation<'_> {\\n noop_visit_mut_type!();\\n\\n /// Although span hygiene is magic, bundler creates invalid code in aspect\\n /// of span hygiene. (The bundled code can have two variables with\\n /// identical name with each other, with respect to span hygiene.)\\n ///\\n /// We avoid bugs caused by the bundler's wrong behavior by\\n /// scoping variables.\\n fn visit_mut_function(&mut self, n: &mut Function) {\\n let scope = Scope::new(&self.scope);\\n let mut v = ConstPropagation { scope };\\n n.visit_mut_children_with(&mut v);\\n }\\n\\n fn visit_mut_var_decl(&mut self, var: &mut VarDecl) {\\n var.decls.visit_mut_with(self);\\n\\n if let VarDeclKind::Const = var.kind {\\n for decl in &var.decls {\\n match &decl.name {\\n Pat::Ident(name) => match &decl.init {\\n Some(init) => match &**init {\\n Expr::Lit(Lit::Bool(..))\\n | Expr::Lit(Lit::Num(..))\\n | Expr::Lit(Lit::Null(..)) => {\\n self.scope.vars.insert(name.to_id(), init.clone());\\n }\\n\\n Expr::Ident(init)\\n if name.id.span.is_dummy()\\n || var.span.is_dummy()\\n || init.span.is_dummy() =>\\n {\\n // This check is required to prevent breaking some codes.\\n if let Some(value) = self.scope.vars.get(&init.to_id()).cloned() {\\n self.scope.vars.insert(name.to_id(), value);\\n } else {\\n self.scope\\n .vars\\n .insert(name.to_id(), Box::new(Expr::Ident(init.clone())));\\n }\\n }\\n _ => {}\\n },\\n None => {}\\n },\\n _ => {}\\n }\\n }\\n }\\n }\\n\\n fn visit_mut_prop(&mut self, p: &mut Prop) {\\n p.visit_mut_children_with(self);\\n\\n match p {\\n Prop::Shorthand(i) => {\\n if let Some(expr) = self.scope.find_var(&i.to_id()) {\\n *p = Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(i.take()),\\n value: expr.clone(),\\n });\\n return;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n /// No-op\\n fn visit_mut_assign_expr(&mut self, _: &mut AssignExpr) {}\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n match e {\\n Expr::Ident(i) => {\\n if let Some(expr) = self.scope.find_var(&i.to_id()) {\\n *e = *expr.clone();\\n return;\\n }\\n }\\n _ => {}\\n }\\n\\n e.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_member_expr(&mut self, e: &mut MemberExpr) {\\n e.obj.visit_mut_with(self);\\n\\n if e.computed {\\n e.prop.visit_mut_with(self);\\n }\\n }\\n\\n fn visit_mut_export_named_specifier(&mut self, n: &mut ExportNamedSpecifier) {\\n if let Some(expr) = self.scope.find_var(&n.orig.to_id()) {\\n match &**expr {\\n Expr::Ident(v) => {\\n let orig = n.orig.clone();\\n n.orig = v.clone();\\n\\n if n.exported.is_none() {\\n n.exported = Some(orig);\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n match &n.exported {\\n Some(exported) => {\\n if exported.sym == n.orig.sym && exported.span.ctxt == n.orig.span.ctxt {\\n n.exported = None;\\n }\\n }\\n None => {}\\n }\\n }\\n}\\n\",\n", + " 'content_id': 'a82af693dd9fb93175e66b77a122fb8fa23f8b20',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/transforms/optimization/src/simplify/const_propgation.rs',\n", + " 'size': 5063,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.38231215186995565,\n", + " 'avg_line_length': 35.29125412541254,\n", + " 'blob_id': '205501ccf1e576340b6e9c1f6b91de1cf0f0dc97',\n", + " 'content': 'use super::graph::Required;\\nuse crate::{id::Id, modules::sort::graph::StmtDepGraph};\\nuse indexmap::IndexSet;\\nuse petgraph::EdgeDirection::{Incoming as Dependants, Outgoing as Dependancies};\\nuse rustc_hash::{FxHashMap, FxHashSet, FxHasher};\\nuse std::{collections::VecDeque, hash::BuildHasherDefault, iter::from_fn, ops::Range};\\nuse swc_atoms::js_word;\\nuse swc_common::{sync::Lrc, util::take::Take, SourceMap, Spanned, SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::find_ids;\\nuse swc_ecma_visit::{noop_visit_type, Node, Visit, VisitWith};\\n\\npub(super) fn sort_stmts(\\n injected_ctxt: SyntaxContext,\\n modules: Vec>,\\n _cm: &Lrc,\\n) -> Vec {\\n let total_len: usize = modules.iter().map(|v| v.len()).sum();\\n\\n let mut stmts = vec![];\\n let mut free = vec![];\\n let mut same_module_ranges = vec![];\\n let mut module_starts = vec![];\\n\\n for module in modules {\\n let start = stmts.len();\\n module_starts.push(stmts.len());\\n let mut module_item_count = 0;\\n\\n for stmt in module {\\n if stmt.span().ctxt == injected_ctxt {\\n free.push(stmt)\\n } else {\\n module_item_count += 1;\\n stmts.push(stmt)\\n }\\n }\\n\\n same_module_ranges.push(start..start + module_item_count);\\n }\\n let non_free_count = stmts.len();\\n let free_range = non_free_count..non_free_count + free.len();\\n stmts.extend(free);\\n\\n // print_hygiene(\\n // &format!(\"before sort\"),\\n // cm,\\n // &Module {\\n // span: DUMMY_SP,\\n // body: stmts.clone(),\\n // shebang: None,\\n // },\\n // );\\n\\n let mut id_graph = calc_deps(&stmts);\\n\\n tracing::debug!(\"Analyzed dependencies between statements\");\\n\\n let orders = iter(\\n &mut id_graph,\\n &same_module_ranges,\\n free_range,\\n &module_starts,\\n &stmts,\\n )\\n .collect::>();\\n\\n tracing::debug!(\"Sorted statements\");\\n\\n debug_assert_eq!(total_len, orders.len());\\n\\n let mut new = Vec::with_capacity(stmts.len());\\n for idx in orders {\\n new.push(stmts[idx].take());\\n }\\n\\n new\\n}\\n\\nfn iter<\\'a>(\\n graph: &\\'a mut StmtDepGraph,\\n same_module_ranges: &\\'a [Range],\\n free: Range,\\n module_starts: &[usize],\\n stmts: &\\'a [ModuleItem],\\n) -> impl \\'a + Iterator {\\n let len = graph.node_count();\\n\\n // dbg!(&same_module_ranges);\\n // dbg!(&free);\\n // dbg!(&module_starts);\\n\\n let mut moves = FxHashSet::default();\\n let mut done = FxHashSet::default();\\n let mut stack = VecDeque::new();\\n stack.extend(module_starts.iter().copied());\\n\\n for &start in module_starts {\\n let range = same_module_ranges\\n .iter()\\n .find(|range| range.contains(&start))\\n .cloned();\\n if let Some(range) = range {\\n for v in range {\\n stack.push_back(v);\\n }\\n }\\n }\\n for v in free.clone() {\\n stack.push_back(v);\\n }\\n\\n from_fn(move || {\\n if done.len() == len {\\n return None;\\n }\\n\\n // Check for first item.\\n \\'main: while let Some(idx) = stack.pop_front() {\\n if done.contains(&idx) {\\n // eprintln!(\"Done: {}\", idx);\\n continue;\\n }\\n let is_free = free.contains(&idx);\\n\\n // dbg!(idx, is_free);\\n // match &stmts[idx] {\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {\\n // let ids: Vec = find_ids(&var.decls);\\n // eprintln!(\"(`{}`) Declare var: `{:?}`\", idx, ids);\\n // }\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Class(cls))) => {\\n // eprintln!(\"(`{}`) Declare class: `{:?}`\", idx, Id::from(&cls.ident));\\n // }\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Fn(f))) => {\\n // eprintln!(\"(`{}`) Declare fn: `{:?}`\", idx, Id::from(&f.ident));\\n // }\\n // _ => eprintln!(\"(`{}`) Stmt\", idx,),\\n // }\\n\\n let current_range = same_module_ranges\\n .iter()\\n .find(|range| range.contains(&idx))\\n .cloned();\\n\\n // dbg!(¤t_range);\\n\\n let can_ignore_deps = match &stmts[idx] {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Fn(..),\\n ..\\n }))\\n | ModuleItem::Stmt(Stmt::Decl(Decl::Fn(..))) => true,\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Class(cls),\\n ..\\n }))\\n | ModuleItem::Stmt(Stmt::Decl(Decl::Class(cls)))\\n if cls.class.super_class.is_none() =>\\n {\\n true\\n }\\n\\n _ => false,\\n };\\n let can_ignore_weak_deps = can_ignore_deps\\n || match &stmts[idx] {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Class(..),\\n ..\\n }))\\n | ModuleItem::Stmt(Stmt::Decl(Decl::Class(..))) => true,\\n _ => false,\\n };\\n\\n // We\\n {\\n let deps = graph\\n .neighbors_directed(idx, Dependancies)\\n .filter(|dep| {\\n let declared_in_same_module = match ¤t_range {\\n Some(v) => v.contains(&dep),\\n None => false,\\n };\\n if declared_in_same_module {\\n return false;\\n }\\n\\n if !free.contains(&idx) && graph.has_a_path(*dep, idx) {\\n if !moves.insert((idx, *dep)) {\\n return false;\\n }\\n }\\n\\n // Exlcude emitted items\\n !done.contains(dep)\\n })\\n .collect::>();\\n\\n // dbg!(&deps);\\n\\n if !deps.is_empty() {\\n let mut deps_to_push = vec![];\\n for dep in deps.iter().rev().copied() {\\n if deps_to_push.contains(&dep) {\\n continue;\\n }\\n\\n let can_ignore_dep = can_ignore_deps\\n || (can_ignore_weak_deps\\n && graph.edge_weight(idx, dep) == Some(Required::Maybe));\\n\\n if can_ignore_dep {\\n if graph.has_a_path(dep, idx) {\\n // Just emit idx.\\n continue;\\n }\\n }\\n\\n deps_to_push.push(dep);\\n }\\n\\n // dbg!(&deps_to_push);\\n\\n if !deps_to_push.is_empty() {\\n // We should check idx again after emitting dependencies.\\n stack.push_front(idx);\\n\\n for dep in deps_to_push {\\n // eprintln!(\"[Move]{} => {}; kind = dep\", idx, dep);\\n stack.push_front(dep)\\n }\\n\\n continue;\\n }\\n }\\n }\\n\\n if is_free {\\n let dependants = graph\\n .neighbors_directed(idx, Dependants)\\n .collect::>();\\n\\n for dependant in dependants {\\n if !done.contains(&dependant) && free.contains(&dependant) {\\n stack.push_front(dependant);\\n }\\n }\\n\\n graph.remove_node(idx);\\n done.insert(idx);\\n return Some(idx);\\n }\\n\\n let current_range = match current_range {\\n Some(v) => v,\\n None => {\\n let dependants = graph\\n .neighbors_directed(idx, Dependants)\\n .collect::>();\\n\\n // dbg!(&dependants);\\n\\n // We only emit free items because we want to emit statements from same module\\n // to emitted closedly.\\n for dependant in dependants {\\n if !done.contains(&dependant) && free.contains(&dependant) {\\n stack.push_front(dependant);\\n }\\n }\\n\\n // It\\'s not within a module, so explicit ordering is not required.\\n graph.remove_node(idx);\\n done.insert(idx);\\n return Some(idx);\\n }\\n };\\n\\n // We should respect original order of statements within a module.\\n for preceding in current_range.clone() {\\n // We should select first statement in module which is not emitted yet.\\n if done.contains(&preceding) {\\n continue;\\n }\\n // dbg!(preceding);\\n if preceding == idx {\\n continue;\\n }\\n if preceding > idx {\\n break;\\n }\\n\\n if !moves.insert((idx, preceding)) {\\n // idx = preceding;\\n continue;\\n }\\n\\n let dependants = graph\\n .neighbors_directed(idx, Dependants)\\n .collect::>();\\n\\n // dbg!(&dependants);\\n\\n // We only emit free items because we want to emit statements from same module\\n // to emitted closedly.\\n for dependant in dependants {\\n if !done.contains(&dependant) && free.contains(&dependant) {\\n stack.push_front(dependant);\\n }\\n }\\n\\n // We found a preceding statement which is not emitted yet.\\n stack.push_front(idx);\\n stack.push_front(preceding);\\n continue \\'main;\\n }\\n\\n graph.remove_node(idx);\\n done.insert(idx);\\n return Some(idx);\\n }\\n\\n None\\n })\\n}\\n\\n/// Using prototype should be treated as an initialization.\\n#[derive(Default)]\\nstruct FieldInitFinter {\\n in_object_assign: bool,\\n in_rhs: bool,\\n accessed: FxHashSet,\\n}\\n\\nimpl FieldInitFinter {\\n fn check_lhs_of_assign(&mut self, lhs: &PatOrExpr) {\\n match lhs {\\n PatOrExpr::Expr(e) => {\\n self.check_lhs_expr_of_assign(&e);\\n }\\n PatOrExpr::Pat(pat) => match &**pat {\\n Pat::Expr(e) => {\\n self.check_lhs_expr_of_assign(&e);\\n }\\n _ => {}\\n },\\n }\\n }\\n fn check_lhs_expr_of_assign(&mut self, lhs: &Expr) {\\n match lhs {\\n Expr::Member(m) => {\\n let obj = match &m.obj {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(obj) => &**obj,\\n };\\n\\n match obj {\\n Expr::Ident(i) => {\\n self.accessed.insert(i.into());\\n }\\n Expr::Member(..) => self.check_lhs_expr_of_assign(&obj),\\n _ => {}\\n }\\n }\\n _ => {}\\n }\\n }\\n}\\n\\nimpl Visit for FieldInitFinter {\\n noop_visit_type!();\\n\\n fn visit_assign_expr(&mut self, e: &AssignExpr, _: &dyn Node) {\\n let old = self.in_rhs;\\n e.left.visit_with(e, self);\\n self.check_lhs_of_assign(&e.left);\\n\\n self.in_rhs = true;\\n e.right.visit_with(e, self);\\n self.in_rhs = old;\\n }\\n\\n fn visit_pat(&mut self, e: &Pat, _: &dyn Node) {\\n let old = self.in_rhs;\\n self.in_rhs = false;\\n e.visit_children_with(self);\\n self.in_rhs = old;\\n }\\n\\n fn visit_call_expr(&mut self, e: &CallExpr, _: &dyn Node) {\\n match &e.callee {\\n ExprOrSuper::Super(_) => {}\\n ExprOrSuper::Expr(callee) => match &**callee {\\n Expr::Member(callee) => match &callee.obj {\\n ExprOrSuper::Expr(callee_obj) => match &**callee_obj {\\n Expr::Ident(Ident {\\n sym: js_word!(\"Object\"),\\n ..\\n }) => match &*callee.prop {\\n Expr::Ident(Ident { sym: prop_sym, .. })\\n if !callee.computed && *prop_sym == *\"assign\" =>\\n {\\n let old = self.in_object_assign;\\n self.in_object_assign = true;\\n\\n e.args.visit_with(e, self);\\n self.in_object_assign = old;\\n\\n return;\\n }\\n _ => {}\\n },\\n _ => {}\\n },\\n ExprOrSuper::Super(_) => {}\\n },\\n\\n _ => {}\\n },\\n }\\n\\n e.visit_children_with(self);\\n }\\n\\n fn visit_member_expr(&mut self, e: &MemberExpr, _: &dyn Node) {\\n e.obj.visit_with(e, self);\\n\\n if e.computed {\\n e.prop.visit_with(e, self);\\n }\\n\\n if !self.in_rhs || self.in_object_assign {\\n match &e.obj {\\n ExprOrSuper::Expr(obj) => match &**obj {\\n Expr::Ident(obj) => match &*e.prop {\\n Expr::Ident(Ident { sym: prop_sym, .. })\\n if !e.computed && *prop_sym == *\"prototype\" =>\\n {\\n self.accessed.insert(obj.into());\\n }\\n _ => {}\\n },\\n _ => {}\\n },\\n\\n _ => {}\\n }\\n }\\n }\\n}\\n\\n/// Finds usage of `ident`\\nstruct InitializerFinder {\\n ident: Id,\\n found: bool,\\n in_complex: bool,\\n}\\n\\nimpl Visit for InitializerFinder {\\n noop_visit_type!();\\n\\n fn visit_pat(&mut self, pat: &Pat, _: &dyn Node) {\\n match pat {\\n Pat::Ident(i) if self.ident == i.id => {\\n self.found = true;\\n }\\n\\n _ => {\\n pat.visit_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_ident(&mut self, i: &Ident, _: &dyn Node) {\\n if self.in_complex && self.ident == *i {\\n self.found = true;\\n }\\n }\\n\\n fn visit_expr_or_spread(&mut self, node: &ExprOrSpread, _: &dyn Node) {\\n let in_complex = self.in_complex;\\n self.in_complex = true;\\n node.visit_children_with(self);\\n self.in_complex = in_complex;\\n }\\n\\n fn visit_member_expr(&mut self, e: &MemberExpr, _: &dyn Node) {\\n {\\n let in_complex = self.in_complex;\\n self.in_complex = true;\\n e.obj.visit_children_with(self);\\n self.in_complex = in_complex;\\n }\\n\\n if e.computed {\\n e.prop.visit_with(e as _, self);\\n }\\n }\\n}\\n\\n/// We do not care about variables created by current statement.\\n/// But we care about modifications.\\n#[derive(Default)]\\nstruct RequirementCalculartor {\\n required_ids: IndexSet<(Id, Required), BuildHasherDefault>,\\n /// While bundling, there can be two bindings with same name and syntax\\n /// context, in case of wrapped es modules. We exclude them from dependency\\n /// graph.\\n excluded: IndexSet>,\\n\\n in_weak: bool,\\n in_var_decl: bool,\\n in_assign_lhs: bool,\\n}\\n\\nmacro_rules! weak {\\n ($name:ident, $T:ty) => {\\n fn $name(&mut self, f: &$T, _: &dyn Node) {\\n let in_weak = self.in_weak;\\n self.in_weak = true;\\n\\n f.visit_children_with(self);\\n\\n self.in_weak = in_weak;\\n }\\n };\\n}\\n\\nimpl RequirementCalculartor {\\n fn insert(&mut self, i: Id) {\\n self.required_ids.insert((\\n i,\\n if self.in_weak {\\n Required::Maybe\\n } else {\\n Required::Always\\n },\\n ));\\n }\\n}\\n\\nimpl Visit for RequirementCalculartor {\\n noop_visit_type!();\\n\\n weak!(visit_arrow_expr, ArrowExpr);\\n weak!(visit_function, Function);\\n weak!(visit_class_method, ClassMethod);\\n weak!(visit_private_method, PrivateMethod);\\n weak!(visit_method_prop, MethodProp);\\n\\n fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier, _: &dyn Node) {\\n self.insert(n.orig.clone().into());\\n }\\n\\n fn visit_assign_expr(&mut self, e: &AssignExpr, _: &dyn Node) {\\n let old = self.in_assign_lhs;\\n\\n self.in_assign_lhs = true;\\n e.left.visit_with(e, self);\\n\\n self.in_assign_lhs = false;\\n e.right.visit_with(e, self);\\n\\n self.in_assign_lhs = old;\\n }\\n\\n fn visit_pat(&mut self, pat: &Pat, _: &dyn Node) {\\n match pat {\\n Pat::Ident(i) => {\\n // We do not care about variables created by current statement.\\n if self.in_var_decl && !self.in_assign_lhs {\\n return;\\n }\\n self.insert(i.id.clone().into());\\n }\\n _ => {\\n pat.visit_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_var_declarator(&mut self, var: &VarDeclarator, _: &dyn Node) {\\n let in_var_decl = self.in_var_decl;\\n self.in_var_decl = true;\\n\\n if self.in_weak {\\n let ids: Vec = find_ids(&var.name);\\n self.excluded.extend(ids);\\n }\\n\\n var.visit_children_with(self);\\n\\n self.in_var_decl = in_var_decl;\\n }\\n\\n fn visit_expr(&mut self, expr: &Expr, _: &dyn Node) {\\n match expr {\\n Expr::Ident(i) => {\\n if self.in_var_decl && self.in_assign_lhs {\\n return;\\n }\\n self.insert(i.into());\\n }\\n _ => {\\n expr.visit_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_prop(&mut self, prop: &Prop, _: &dyn Node) {\\n match prop {\\n Prop::Shorthand(i) => {\\n self.insert(i.into());\\n }\\n _ => prop.visit_children_with(self),\\n }\\n }\\n\\n fn visit_member_expr(&mut self, e: &MemberExpr, _: &dyn Node) {\\n e.obj.visit_with(e as _, self);\\n\\n if e.computed {\\n e.prop.visit_with(e as _, self);\\n }\\n }\\n}\\n\\nfn calc_deps(new: &[ModuleItem]) -> StmtDepGraph {\\n tracing::debug!(\"Analyzing dependencies between statements\");\\n let mut graph = StmtDepGraph::default();\\n\\n let mut declared_by = FxHashMap::>::default();\\n let mut uninitialized_ids = FxHashMap::::default();\\n\\n for (idx, item) in new.iter().enumerate() {\\n graph.add_node(idx);\\n\\n // We start by calculating ids created by statements. Note that we don\\'t need to\\n // analyze bodies of functions nor members of classes, because it\\'s not\\n // evaludated until they are called.\\n\\n match item {\\n // We only check declarations because ids are created by declarations.\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl { decl, .. }))\\n | ModuleItem::Stmt(Stmt::Decl(decl)) => {\\n //\\n match decl {\\n Decl::Class(ClassDecl { ident, .. }) | Decl::Fn(FnDecl { ident, .. }) => {\\n // eprintln!(\"Decl: `{}` declares {:?}`\", idx, Id::from(ident));\\n declared_by.entry(Id::from(ident)).or_default().push(idx);\\n }\\n Decl::Var(vars) => {\\n for var in &vars.decls {\\n //\\n let ids: Vec = find_ids(&var.name);\\n for id in ids {\\n if var.init.is_none() {\\n uninitialized_ids.insert(id.clone(), idx);\\n }\\n\\n // eprintln!(\"Decl: `{}` declares {:?}`\", idx, id);\\n declared_by.entry(id).or_default().push(idx);\\n }\\n }\\n }\\n _ => {}\\n }\\n }\\n _ => {}\\n }\\n\\n {\\n // Find extra initializations.\\n let mut v = FieldInitFinter::default();\\n item.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n\\n for id in v.accessed {\\n if let Some(declarator_indexes) = declared_by.get(&id) {\\n // let idx_decl = match &item {\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {\\n // let ids: Vec = find_ids(&var.decls);\\n // format!(\"`{:?}`\", ids)\\n // }\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Class(c))) => {\\n // format!(\"{}{:?}\", c.ident.sym, c.ident.span.ctxt)\\n // }\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Fn(f))) => {\\n // format!(\"{}{:?}\", f.ident.sym, f.ident.span.ctxt)\\n // }\\n // _ => String::from(\"\"),\\n // };\\n\\n for &declarator_index in declarator_indexes {\\n if declarator_index != idx {\\n graph.add_edge(idx, declarator_index, Required::Always);\\n // eprintln!(\\n // \"Field init: `{}` ({}) depends on `{}`:\\n // {:?}\",\\n // idx, idx_decl, declarator_index, &id\\n // );\\n }\\n }\\n\\n // eprintln!(\"`{}` declares {:?}`\", idx, id);\\n declared_by.entry(id).or_default().push(idx);\\n }\\n }\\n }\\n }\\n\\n // Handle uninitialized variables\\n //\\n // Compiled typescript enum is not initialized by declaration\\n //\\n // var Status;\\n // (function(Status){})(Status)\\n for (uninit_id, start_idx) in uninitialized_ids {\\n for (idx, item) in new.iter().enumerate().filter(|(idx, _)| *idx > start_idx) {\\n let mut finder = InitializerFinder {\\n ident: uninit_id.clone(),\\n found: false,\\n in_complex: false,\\n };\\n item.visit_with(&Invalid { span: DUMMY_SP }, &mut finder);\\n if finder.found {\\n declared_by.entry(uninit_id).or_default().push(idx);\\n break;\\n }\\n }\\n }\\n\\n for (idx, item) in new.iter().enumerate() {\\n // We then calculate which ids a statement require to be executed.\\n // Again, we don\\'t need to analyze non-top-level idents because they\\n // are not evaluated while lpoading module.\\n\\n let mut visitor = RequirementCalculartor::default();\\n\\n item.visit_with(&Invalid { span: DUMMY_SP }, &mut visitor);\\n\\n for (id, kind) in visitor.required_ids {\\n if visitor.excluded.contains(&id) {\\n continue;\\n }\\n\\n if let Some(declarator_indexes) = declared_by.get(&id) {\\n for &declarator_index in declarator_indexes {\\n if declarator_index != idx {\\n // let idx_decl = match &item {\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {\\n // let ids: Vec = find_ids(&var.decls);\\n // format!(\"`{:?}`\", ids)\\n // }\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Class(c))) => {\\n // format!(\"{}{:?}\", c.ident.sym, c.ident.span.ctxt)\\n // }\\n // ModuleItem::Stmt(Stmt::Decl(Decl::Fn(f))) => {\\n // format!(\"{}{:?}\", f.ident.sym, f.ident.span.ctxt)\\n // }\\n // _ => String::from(\"\"),\\n // };\\n\\n graph.add_edge(idx, declarator_index, kind);\\n // eprintln!(\\n // \"`{}` ({}) depends on `{}`: {:?}\",\\n // idx, idx_decl, declarator_index, &id\\n // );\\n if cfg!(debug_assertions) {\\n let deps: Vec<_> =\\n graph.neighbors_directed(idx, Dependancies).collect();\\n assert!(deps.contains(&declarator_index));\\n }\\n }\\n }\\n }\\n }\\n }\\n\\n graph\\n}\\n\\n#[cfg(test)]\\nmod tests {\\n use super::{calc_deps, Dependancies};\\n use crate::{bundler::tests::suite, debug::print_hygiene};\\n use swc_common::DUMMY_SP;\\n use swc_ecma_ast::*;\\n\\n fn assert_no_cycle(s: &str) {\\n suite().file(\"main.js\", s).run(|t| {\\n let info = t.module(\"main.js\");\\n let module = (*info.module).clone();\\n\\n let graph = calc_deps(&module.body);\\n\\n for i in 0..module.body.len() {\\n match &module.body[i] {\\n ModuleItem::Stmt(Stmt::Decl(Decl::Fn(..))) => continue,\\n\\n _ => {}\\n }\\n\\n let deps = graph\\n .neighbors_directed(i, Dependancies)\\n .collect::>();\\n\\n for dep in deps {\\n match &module.body[dep] {\\n ModuleItem::Stmt(Stmt::Decl(Decl::Fn(..))) => continue,\\n\\n _ => {}\\n }\\n print_hygiene(\\n \"first item\",\\n &t.cm,\\n &Module {\\n span: DUMMY_SP,\\n body: vec![module.body[dep].clone()],\\n shebang: None,\\n },\\n );\\n print_hygiene(\\n \"second item\",\\n &t.cm,\\n &Module {\\n span: DUMMY_SP,\\n body: vec![module.body[i].clone()],\\n shebang: None,\\n },\\n );\\n assert!(\\n !graph.has_a_path(dep, i),\\n \"{} and {} is dependant to each other\",\\n dep,\\n i,\\n );\\n }\\n }\\n\\n Ok(())\\n });\\n }\\n\\n #[test]\\n fn no_cycle_1() {\\n assert_no_cycle(\\n r#\"\\n function lexer(str) {\\n const tokens = [];\\n let i = 0;\\n while(i < str.length){\\n const char = str[i];\\n if (char === \"*\" || char === \"+\" || char === \"?\") {\\n tokens.push({\\n type: \"MODIFIER\",\\n index: i,\\n value: str[i++]\\n });\\n continue;\\n }\\n if (char === \"\\\\\\\\\") {\\n tokens.push({\\n type: \"ESCAPED_CHAR\",\\n index: i++,\\n value: str[i++]\\n });\\n continue;\\n }\\n if (char === \"{\") {\\n tokens.push({\\n type: \"OPEN\",\\n index: i,\\n value: str[i++]\\n });\\n continue;\\n }\\n if (char === \"}\") {\\n tokens.push({\\n type: \"CLOSE\",\\n index: i,\\n value: str[i++]\\n });\\n continue;\\n }\\n if (char === \":\") {\\n let name = \"\";\\n let j = i + 1;\\n while(j < str.length){\\n const code = str.charCodeAt(j);\\n if ((code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95) {\\n name += str[j++];\\n continue;\\n }\\n break;\\n }\\n if (!name) throw new TypeError(`Missing parameter name at ${i}`);\\n tokens.push({\\n type: \"NAME\",\\n index: i,\\n value: name\\n });\\n i = j;\\n continue;\\n }\\n if (char === \"(\") {\\n let count = 1;\\n let pattern = \"\";\\n let j = i + 1;\\n if (str[j] === \"?\") {\\n throw new TypeError(`Pattern cannot start with \"?\" at ${j}`);\\n }\\n while(j < str.length){\\n if (str[j] === \"\\\\\\\\\") {\\n pattern += str[j++] + str[j++];\\n continue;\\n }\\n if (str[j] === \")\") {\\n count--;\\n if (count === 0) {\\n j++;\\n break;\\n }\\n } else if (str[j] === \"(\") {\\n count++;\\n if (str[j + 1] !== \"?\") {\\n throw new TypeError(`Capturing groups are not allowed at ${j}`);\\n }\\n }\\n pattern += str[j++];\\n }\\n if (count) throw new TypeError(`Unbalanced pattern at ${i}`);\\n if (!pattern) throw new TypeError(`Missing pattern at ${i}`);\\n tokens.push({\\n type: \"PATTERN\",\\n index: i,\\n value: pattern\\n });\\n i = j;\\n continue;\\n }\\n tokens.push({\\n type: \"CHAR\",\\n index: i,\\n value: str[i++]\\n });\\n }\\n tokens.push({\\n type: \"END\",\\n index: i,\\n value: \"\"\\n });\\n return tokens;\\n }\\n function parse(str, options = {\\n }) {\\n const tokens = lexer(str);\\n const { prefixes =\"./\" } = options;\\n const defaultPattern = `[^${escapeString(options.delimiter || \"/#?\")}]+?`;\\n const result = [];\\n let key = 0;\\n let i = 0;\\n let path = \"\";\\n const tryConsume = (type)=>{\\n if (i < tokens.length && tokens[i].type === type) return tokens[i++].value;\\n };\\n const mustConsume = (type)=>{\\n const value = tryConsume(type);\\n if (value !== undefined) return value;\\n const { type: nextType , index } = tokens[i];\\n throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}`);\\n };\\n const consumeText = ()=>{\\n let result1 = \"\";\\n let value;\\n while((value = tryConsume(\"CHAR\") || tryConsume(\"ESCAPED_CHAR\"))){\\n result1 += value;\\n }\\n return result1;\\n };\\n while(i < tokens.length){\\n const char = tryConsume(\"CHAR\");\\n const name = tryConsume(\"NAME\");\\n const pattern = tryConsume(\"PATTERN\");\\n if (name || pattern) {\\n let prefix = char || \"\";\\n if (prefixes.indexOf(prefix) === -1) {\\n path += prefix;\\n prefix = \"\";\\n }\\n if (path) {\\n result.push(path);\\n path = \"\";\\n }\\n result.push({\\n name: name || key++,\\n prefix,\\n suffix: \"\",\\n pattern: pattern || defaultPattern,\\n modifier: tryConsume(\"MODIFIER\") || \"\"\\n });\\n continue;\\n }\\n const value = char || tryConsume(\"ESCAPED_CHAR\");\\n if (value) {\\n path += value;\\n continue;\\n }\\n if (path) {\\n result.push(path);\\n path = \"\";\\n }\\n const open = tryConsume(\"OPEN\");\\n if (open) {\\n const prefix = consumeText();\\n const name1 = tryConsume(\"NAME\") || \"\";\\n const pattern1 = tryConsume(\"PATTERN\") || \"\";\\n const suffix = consumeText();\\n mustConsume(\"CLOSE\");\\n result.push({\\n name: name1 || (pattern1 ? key++ : \"\"),\\n pattern: name1 && !pattern1 ? defaultPattern : pattern1,\\n prefix,\\n suffix,\\n modifier: tryConsume(\"MODIFIER\") || \"\"\\n });\\n continue;\\n }\\n mustConsume(\"END\");\\n }\\n return result;\\n }\\n const parse1 = parse;\\n function compile(str, options) {\\n return tokensToFunction(parse(str, options), options);\\n }\\n const compile1 = compile;\\n function tokensToFunction(tokens, options = {\\n }) {\\n const reFlags = flags(options);\\n const { encode =(x)=>x\\n , validate =true } = options;\\n const matches = tokens.map((token)=>{\\n if (typeof token === \"object\") {\\n return new RegExp(`^(?:${token.pattern})$`, reFlags);\\n }\\n });\\n return (data)=>{\\n let path = \"\";\\n for(let i = 0; i < tokens.length; i++){\\n const token = tokens[i];\\n if (typeof token === \"string\") {\\n path += token;\\n continue;\\n }\\n const value = data ? data[token.name] : undefined;\\n const optional = token.modifier === \"?\" || token.modifier === \"*\";\\n const repeat = token.modifier === \"*\" || token.modifier === \"+\";\\n if (Array.isArray(value)) {\\n if (!repeat) {\\n throw new TypeError(`Expected \"${token.name}\" to not repeat, but got an array`);\\n }\\n if (value.length === 0) {\\n if (optional) continue;\\n throw new TypeError(`Expected \"${token.name}\" to not be empty`);\\n }\\n for(let j = 0; j < value.length; j++){\\n const segment = encode(value[j], token);\\n if (validate && !(matches[i]).test(segment)) {\\n throw new TypeError(`Expected all \"${token.name}\" to match \"${token.pattern}\", but got \"${segment}\"`);\\n }\\n path += token.prefix + segment + token.suffix;\\n }\\n continue;\\n }\\n if (typeof value === \"string\" || typeof value === \"number\") {\\n const segment = encode(String(value), token);\\n if (validate && !(matches[i]).test(segment)) {\\n throw new TypeError(`Expected \"${token.name}\" to match \"${token.pattern}\", but got \"${segment}\"`);\\n }\\n path += token.prefix + segment + token.suffix;\\n continue;\\n }\\n if (optional) continue;\\n const typeOfMessage = repeat ? \"an array\" : \"a string\";\\n throw new TypeError(`Expected \"${token.name}\" to be ${typeOfMessage}`);\\n }\\n return path;\\n };\\n }\\n const tokensToFunction1 = tokensToFunction;\\n function match(str, options) {\\n const keys = [];\\n const re = pathToRegexp(str, keys, options);\\n return regexpToFunction(re, keys, options);\\n }\\n const match1 = match;\\n function regexpToFunction(re, keys, options = {\\n }) {\\n const { decode =(x)=>x\\n } = options;\\n return function(pathname) {\\n const m = re.exec(pathname);\\n if (!m) return false;\\n const { 0: path , index } = m;\\n const params = Object.create(null);\\n for(let i = 1; i < m.length; i++){\\n if (m[i] === undefined) continue;\\n const key = keys[i - 1];\\n if (key.modifier === \"*\" || key.modifier === \"+\") {\\n params[key.name] = m[i].split(key.prefix + key.suffix).map((value)=>{\\n return decode(value, key);\\n });\\n } else {\\n params[key.name] = decode(m[i], key);\\n }\\n }\\n return {\\n path,\\n index,\\n params\\n };\\n };\\n }\\n const regexpToFunction1 = regexpToFunction;\\n function escapeString(str) {\\n return str.replace(/([.+*?=^!:${}()[\\\\]|/\\\\\\\\])/g, \"\\\\\\\\$1\");\\n }\\n function flags(options) {\\n return options && options.sensitive ? \"\" : \"i\";\\n }\\n function regexpToRegexp(path, keys) {\\n if (!keys) return path;\\n const groupsRegex = /\\\\((?:\\\\?<(.*?)>)?(?!\\\\?)/g;\\n let index = 0;\\n let execResult = groupsRegex.exec(path.source);\\n while(execResult){\\n keys.push({\\n name: execResult[1] || index++,\\n prefix: \"\",\\n suffix: \"\",\\n modifier: \"\",\\n pattern: \"\"\\n });\\n execResult = groupsRegex.exec(path.source);\\n }\\n return path;\\n }\\n function arrayToRegexp(paths, keys, options) {\\n const parts = paths.map((path)=>pathToRegexp(path, keys, options).source\\n );\\n return new RegExp(`(?:${parts.join(\"|\")})`, flags(options));\\n }\\n function stringToRegexp(path, keys, options) {\\n return tokensToRegexp(parse(path, options), keys, options);\\n }\\n function tokensToRegexp(tokens, keys, options = {\\n }) {\\n const { strict =false , start =true , end =true , encode =(x)=>x\\n } = options;\\n const endsWith = `[${escapeString(options.endsWith || \"\")}]|$`;\\n const delimiter = `[${escapeString(options.delimiter || \"/#?\")}]`;\\n let route = start ? \"^\" : \"\";\\n for (const token of tokens){\\n if (typeof token === \"string\") {\\n route += escapeString(encode(token));\\n } else {\\n const prefix = escapeString(encode(token.prefix));\\n const suffix = escapeString(encode(token.suffix));\\n if (token.pattern) {\\n if (keys) keys.push(token);\\n if (prefix || suffix) {\\n if (token.modifier === \"+\" || token.modifier === \"*\") {\\n const mod = token.modifier === \"*\" ? \"?\" : \"\";\\n route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`;\\n } else {\\n route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;\\n }\\n } else {\\n route += `(${token.pattern})${token.modifier}`;\\n }\\n } else {\\n route += `(?:${prefix}${suffix})${token.modifier}`;\\n }\\n }\\n }\\n if (end) {\\n if (!strict) route += `${delimiter}?`;\\n route += !options.endsWith ? \"$\" : `(?=${endsWith})`;\\n } else {\\n const endToken = tokens[tokens.length - 1];\\n const isEndDelimited = typeof endToken === \"string\" ? delimiter.indexOf(endToken[endToken.length - 1]) > -1 : endToken === undefined;\\n if (!strict) {\\n route += `(?:${delimiter}(?=${endsWith}))?`;\\n }\\n if (!isEndDelimited) {\\n route += `(?=${delimiter}|${endsWith})`;\\n }\\n }\\n return new RegExp(route, flags(options));\\n }\\n const tokensToRegexp1 = tokensToRegexp;\\n function pathToRegexp(path, keys, options) {\\n if (path instanceof RegExp) return regexpToRegexp(path, keys);\\n if (Array.isArray(path)) return arrayToRegexp(path, keys, options);\\n return stringToRegexp(path, keys, options);\\n }\\n const pathToRegexp1 = pathToRegexp;\\n \"#,\\n );\\n }\\n}\\n',\n", + " 'content_id': '357bcb0e85c9d23c2a296605f66f4b10989506d6',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 153,\n", + " 'path': '/bundler/src/modules/sort/stmt.rs',\n", + " 'size': 43985,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.40668125586173015,\n", + " 'avg_line_length': 34.654458598726116,\n", + " 'blob_id': 'cad75ffa6409b25e422ccad17adfdde51c05a4e4',\n", + " 'content': 'use super::EnumKind;\\nuse rustc_hash::FxHashMap;\\nuse swc_atoms::js_word;\\nuse swc_common::{util::move_map::MoveMap, Spanned, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, member_expr, quote_ident, undefined, ExprFactory, Id};\\nuse swc_ecma_visit::{noop_fold_type, Fold, FoldWith};\\n\\n/// https://github.com/leonardfactory/babel-plugin-transform-typescript-metadata/blob/master/src/parameter/parameterVisitor.ts\\npub(super) struct ParamMetadata;\\n\\nimpl Fold for ParamMetadata {\\n noop_fold_type!();\\n\\n fn fold_class(&mut self, mut cls: Class) -> Class {\\n cls = cls.fold_children_with(self);\\n let mut decorators = cls.decorators;\\n\\n cls.body = cls.body.move_map(|m| match m {\\n ClassMember::Constructor(mut c) => {\\n for (idx, param) in c.params.iter_mut().enumerate() {\\n //\\n match param {\\n ParamOrTsParamProp::TsParamProp(p) => {\\n for decorator in p.decorators.drain(..) {\\n let new_dec =\\n self.create_param_decorator(idx, decorator.expr, true);\\n decorators.push(new_dec);\\n }\\n }\\n ParamOrTsParamProp::Param(param) => {\\n for decorator in param.decorators.drain(..) {\\n let new_dec =\\n self.create_param_decorator(idx, decorator.expr, true);\\n decorators.push(new_dec);\\n }\\n }\\n }\\n }\\n\\n ClassMember::Constructor(c)\\n }\\n _ => m,\\n });\\n cls.decorators = decorators;\\n\\n cls\\n }\\n\\n fn fold_class_method(&mut self, mut m: ClassMethod) -> ClassMethod {\\n for (idx, param) in m.function.params.iter_mut().enumerate() {\\n for decorator in param.decorators.drain(..) {\\n let new_dec = self.create_param_decorator(idx, decorator.expr, false);\\n m.function.decorators.push(new_dec);\\n }\\n }\\n\\n m\\n }\\n}\\n\\nimpl ParamMetadata {\\n fn create_param_decorator(\\n &self,\\n param_index: usize,\\n decorator_expr: Box,\\n is_constructor: bool,\\n ) -> Decorator {\\n Decorator {\\n span: DUMMY_SP,\\n expr: Box::new(Expr::Fn(FnExpr {\\n ident: None,\\n function: Function {\\n params: vec![\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"target\").into()),\\n },\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"key\").into()),\\n },\\n ],\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: decorator_expr.as_callee(),\\n args: vec![\\n quote_ident!(\"target\").as_arg(),\\n if is_constructor {\\n quote_ident!(\"undefined\").as_arg()\\n } else {\\n quote_ident!(\"key\").as_arg()\\n },\\n Lit::Num(Number {\\n span: DUMMY_SP,\\n value: param_index as _,\\n })\\n .as_arg(),\\n ],\\n type_args: Default::default(),\\n }))),\\n })],\\n }),\\n decorators: Default::default(),\\n span: Default::default(),\\n is_generator: Default::default(),\\n is_async: Default::default(),\\n type_params: Default::default(),\\n return_type: Default::default(),\\n },\\n })),\\n }\\n }\\n}\\n\\n/// https://github.com/leonardfactory/babel-plugin-transform-typescript-metadata/blob/master/src/metadata/metadataVisitor.ts\\npub(super) struct Metadata<\\'a> {\\n pub(super) enums: &\\'a FxHashMap,\\n\\n pub(super) class_name: Option<&\\'a Ident>,\\n}\\n\\nimpl Fold for Metadata<\\'_> {\\n noop_fold_type!();\\n\\n fn fold_class(&mut self, mut c: Class) -> Class {\\n c = c.fold_children_with(self);\\n\\n if c.decorators.is_empty() {\\n return c;\\n }\\n\\n let constructor = c.body.iter().find_map(|m| match m {\\n ClassMember::Constructor(c) => Some(c),\\n _ => None,\\n });\\n if constructor.is_none() {\\n return c;\\n }\\n\\n {\\n let dec = self\\n .create_metadata_design_decorator(\"design:type\", quote_ident!(\"Function\").as_arg());\\n c.decorators.push(dec);\\n }\\n {\\n let dec = self.create_metadata_design_decorator(\\n \"design:paramtypes\",\\n ArrayLit {\\n span: DUMMY_SP,\\n elems: constructor\\n .as_ref()\\n .unwrap()\\n .params\\n .iter()\\n .map(|v| match v {\\n ParamOrTsParamProp::TsParamProp(p) => {\\n let ann = match &p.param {\\n TsParamPropParam::Ident(i) => i.type_ann.as_ref(),\\n TsParamPropParam::Assign(a) => get_type_ann_of_pat(&a.left),\\n };\\n Some(serialize_type(self.class_name, ann).as_arg())\\n }\\n ParamOrTsParamProp::Param(p) => Some(\\n serialize_type(self.class_name, get_type_ann_of_pat(&p.pat))\\n .as_arg(),\\n ),\\n })\\n .collect(),\\n }\\n .as_arg(),\\n );\\n c.decorators.push(dec);\\n }\\n c\\n }\\n\\n fn fold_class_method(&mut self, mut m: ClassMethod) -> ClassMethod {\\n if m.function.decorators.is_empty() {\\n return m;\\n }\\n\\n {\\n let dec = self\\n .create_metadata_design_decorator(\"design:type\", quote_ident!(\"Function\").as_arg());\\n m.function.decorators.push(dec);\\n }\\n {\\n let dec = self.create_metadata_design_decorator(\\n \"design:paramtypes\",\\n ArrayLit {\\n span: DUMMY_SP,\\n elems: m\\n .function\\n .params\\n .iter()\\n .map(|v| {\\n Some(\\n serialize_type(self.class_name, get_type_ann_of_pat(&v.pat))\\n .as_arg(),\\n )\\n })\\n .collect(),\\n }\\n .as_arg(),\\n );\\n m.function.decorators.push(dec);\\n }\\n m\\n }\\n\\n fn fold_class_prop(&mut self, mut p: ClassProp) -> ClassProp {\\n if p.decorators.is_empty() {\\n return p;\\n }\\n\\n if p.type_ann.is_none() {\\n return p;\\n }\\n\\n if let Some(name) = p\\n .type_ann\\n .as_ref()\\n .map(|ty| &ty.type_ann)\\n .map(|type_ann| match &**type_ann {\\n TsType::TsTypeRef(r) => Some(r),\\n _ => None,\\n })\\n .flatten()\\n .map(|r| match &r.type_name {\\n TsEntityName::TsQualifiedName(_) => None,\\n TsEntityName::Ident(i) => Some(i),\\n })\\n .flatten()\\n {\\n if let Some(kind) = self.enums.get(&name.to_id()) {\\n let dec = self.create_metadata_design_decorator(\\n \"design:type\",\\n match kind {\\n EnumKind::Mixed => quote_ident!(\"Object\").as_arg(),\\n EnumKind::Str => quote_ident!(\"String\").as_arg(),\\n EnumKind::Num => quote_ident!(\"Number\").as_arg(),\\n },\\n );\\n p.decorators.push(dec);\\n return p;\\n }\\n }\\n\\n let dec = self.create_metadata_design_decorator(\\n \"design:type\",\\n serialize_type(self.class_name, p.type_ann.as_ref()).as_arg(),\\n );\\n p.decorators.push(dec);\\n\\n p\\n }\\n}\\n\\nimpl Metadata<\\'_> {\\n fn create_metadata_design_decorator(&self, design: &str, type_arg: ExprOrSpread) -> Decorator {\\n Decorator {\\n span: DUMMY_SP,\\n expr: Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"typeof\"),\\n arg: Box::new(Expr::Ident(quote_ident!(\"Reflect\"))),\\n })),\\n op: op!(\"!==\"),\\n right: Box::new(Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: \"undefined\".into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n })),\\n op: op!(\"&&\"),\\n right: Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"typeof\"),\\n arg: member_expr!(DUMMY_SP, Reflect.metadata),\\n })),\\n op: op!(\"===\"),\\n right: Box::new(Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: \"function\".into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n })),\\n })),\\n op: op!(\"&&\"),\\n right: Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: member_expr!(DUMMY_SP, Reflect.metadata).as_callee(),\\n args: vec![\\n Str {\\n span: DUMMY_SP,\\n value: design.into(),\\n has_escape: false,\\n kind: Default::default(),\\n }\\n .as_arg(),\\n type_arg,\\n ],\\n\\n type_args: Default::default(),\\n })),\\n })),\\n }\\n }\\n}\\n\\nfn serialize_type(class_name: Option<&Ident>, param: Option<&TsTypeAnn>) -> Expr {\\n fn serialize_type_ref(class_name: &str, ty: &TsTypeRef) -> Expr {\\n match &ty.type_name {\\n // We should omit references to self (class) since it will throw a ReferenceError at\\n // runtime due to babel transpile output.\\n TsEntityName::Ident(i) if &*i.sym == class_name => {\\n return quote_ident!(\"Object\").into()\\n }\\n _ => {}\\n }\\n\\n let member_expr = ts_entity_to_member_expr(&ty.type_name);\\n\\n fn check_object_existed(expr: Box) -> Box {\\n match *expr {\\n Expr::Member(ref member_expr) => {\\n let obj_expr = match member_expr.obj {\\n ExprOrSuper::Expr(ref exp) => exp.clone(),\\n ExprOrSuper::Super(_) => panic!(\"Unreachable code path\"),\\n };\\n Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: check_object_existed(obj_expr),\\n op: op!(\"||\"),\\n right: Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"typeof\"),\\n arg: expr.clone(),\\n })),\\n op: op!(\"===\"),\\n right: Box::new(Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: \"undefined\".into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n })),\\n }))\\n }\\n _ => Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"typeof\"),\\n arg: expr.clone(),\\n })),\\n op: op!(\"===\"),\\n right: Box::new(Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: \"undefined\".into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n })),\\n }\\n }\\n\\n // We don\\'t know if type is just a type (interface, etc.) or a concrete value\\n // (class, etc.)\\n //\\n // `typeof` operator allows us to use the expression even if it is not defined,\\n // fallback is just `Object`.\\n\\n Expr::Cond(CondExpr {\\n span: DUMMY_SP,\\n test: check_object_existed(Box::new(member_expr.clone())),\\n cons: Box::new(quote_ident!(\"Object\").into()),\\n alt: Box::new(member_expr),\\n })\\n }\\n\\n fn serialize_type_list(class_name: &str, types: &[Box]) -> Expr {\\n let mut u = None;\\n\\n for ty in types {\\n // Skip parens if need be\\n let ty = match &**ty {\\n TsType::TsParenthesizedType(ty) => &ty.type_ann,\\n _ => ty,\\n };\\n\\n match &**ty {\\n // Always elide `never` from the union/intersection if possible\\n TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsNeverKeyword,\\n ..\\n }) => {\\n continue;\\n }\\n\\n // Elide null and undefined from unions for metadata, just like what we did prior to\\n // the implementation of strict null checks\\n TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsNullKeyword,\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsUndefinedKeyword,\\n ..\\n }) => {\\n continue;\\n }\\n\\n _ => {}\\n }\\n\\n let item = serialize_type_node(class_name, &ty);\\n\\n // One of the individual is global object, return immediately\\n match item {\\n Expr::Ident(Ident {\\n sym: js_word!(\"Object\"),\\n ..\\n }) => return item,\\n _ => {}\\n }\\n\\n // If there exists union that is not void 0 expression, check if the\\n // the common type is identifier. anything more complex\\n // and we will just default to Object\\n\\n //\\n match &u {\\n None => {\\n u = Some(item);\\n }\\n\\n Some(prev) => {\\n // Check for different types\\n match prev {\\n Expr::Ident(prev) => match &item {\\n Expr::Ident(item) if prev.sym == item.sym => {}\\n _ => return quote_ident!(\"Object\").into(),\\n },\\n\\n _ => return quote_ident!(\"Object\").into(),\\n }\\n }\\n }\\n }\\n\\n *undefined(DUMMY_SP)\\n }\\n\\n fn serialize_type_node(class_name: &str, ty: &TsType) -> Expr {\\n let span = ty.span();\\n match ty {\\n TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsVoidKeyword,\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsUndefinedKeyword,\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsNullKeyword,\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsNeverKeyword,\\n ..\\n }) => return *undefined(span),\\n\\n TsType::TsParenthesizedType(ty) => serialize_type_node(class_name, &*ty.type_ann),\\n\\n TsType::TsFnOrConstructorType(_) => quote_ident!(\"Function\").into(),\\n\\n TsType::TsArrayType(_) | TsType::TsTupleType(_) => quote_ident!(\"Array\").into(),\\n\\n TsType::TsLitType(TsLitType {\\n lit: TsLit::Bool(..),\\n ..\\n })\\n | TsType::TsTypePredicate(_)\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsBooleanKeyword,\\n ..\\n }) => quote_ident!(\"Boolean\").into(),\\n\\n ty if is_str(ty) => quote_ident!(\"String\").into(),\\n\\n TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsObjectKeyword,\\n ..\\n }) => quote_ident!(\"Object\").into(),\\n\\n TsType::TsLitType(TsLitType {\\n lit: TsLit::Number(..),\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsNumberKeyword,\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsBigIntKeyword,\\n ..\\n }) => quote_ident!(\"Number\").into(),\\n\\n TsType::TsLitType(ty) => {\\n // TODO: Proper error reporting\\n panic!(\"Bad type for decoration: {:?}\", ty);\\n }\\n\\n TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsSymbolKeyword,\\n ..\\n }) => quote_ident!(\"Symbol\").into(),\\n\\n TsType::TsTypeQuery(_)\\n | TsType::TsTypeOperator(_)\\n | TsType::TsIndexedAccessType(_)\\n | TsType::TsTypeLit(_)\\n | TsType::TsMappedType(_)\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsAnyKeyword,\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsUnknownKeyword,\\n ..\\n })\\n | TsType::TsThisType(..) => quote_ident!(\"Object\").into(),\\n\\n TsType::TsUnionOrIntersectionType(ty) => match ty {\\n TsUnionOrIntersectionType::TsUnionType(ty) => {\\n serialize_type_list(class_name, &ty.types)\\n }\\n TsUnionOrIntersectionType::TsIntersectionType(ty) => {\\n serialize_type_list(class_name, &ty.types)\\n }\\n },\\n\\n TsType::TsConditionalType(ty) => {\\n serialize_type_list(class_name, &[ty.true_type.clone(), ty.false_type.clone()])\\n }\\n\\n TsType::TsTypeRef(ty) => serialize_type_ref(class_name, ty),\\n\\n _ => panic!(\"Bad type for decorator: {:?}\", ty),\\n }\\n }\\n\\n let param = match param {\\n Some(v) => &v.type_ann,\\n None => return *undefined(DUMMY_SP),\\n };\\n\\n serialize_type_node(class_name.map(|v| &*v.sym).unwrap_or(\"\"), &**param)\\n}\\n\\nfn ts_entity_to_member_expr(type_name: &TsEntityName) -> Expr {\\n match type_name {\\n TsEntityName::TsQualifiedName(q) => {\\n let obj = ts_entity_to_member_expr(&q.left);\\n\\n Expr::Member(MemberExpr {\\n span: DUMMY_SP,\\n obj: obj.as_obj(),\\n prop: Box::new(Expr::Ident(q.right.clone())),\\n computed: false,\\n })\\n }\\n TsEntityName::Ident(i) => Expr::Ident(i.clone()),\\n }\\n}\\n\\nfn get_type_ann_of_pat(p: &Pat) -> Option<&TsTypeAnn> {\\n match p {\\n Pat::Ident(p) => &p.type_ann,\\n Pat::Array(p) => &p.type_ann,\\n Pat::Rest(p) => &p.type_ann,\\n Pat::Object(p) => &p.type_ann,\\n Pat::Assign(p) => &p.type_ann,\\n Pat::Invalid(_) => return None,\\n Pat::Expr(_) => return None,\\n }\\n .as_ref()\\n}\\n\\nfn is_str(ty: &TsType) -> bool {\\n match ty {\\n TsType::TsLitType(TsLitType {\\n lit: TsLit::Str(..),\\n ..\\n })\\n | TsType::TsKeywordType(TsKeywordType {\\n kind: TsKeywordTypeKind::TsStringKeyword,\\n ..\\n }) => true,\\n\\n TsType::TsUnionOrIntersectionType(TsUnionOrIntersectionType::TsUnionType(u)) => {\\n u.types.iter().all(|ty| is_str(ty))\\n }\\n\\n _ => false,\\n }\\n}\\n',\n", + " 'content_id': '3a8e468856c566fb784cc934f309c792b0144cb8',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 126,\n", + " 'path': '/ecmascript/transforms/proposal/src/decorators/legacy/metadata.rs',\n", + " 'size': 22391,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5751633986928104,\n", + " 'avg_line_length': 29.6,\n", + " 'blob_id': 'e5522f13eef9fd7d74e11e2aa1c681c8ee3d0d32',\n", + " 'content': \"use crate::{Bundler, Load, Resolve};\\nuse swc_common::pass::Repeat;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms::optimization::simplify::{const_propgation::constant_propagation, dce};\\nuse swc_ecma_visit::FoldWith;\\n\\nimpl Bundler<'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// If used_exports is [None], all exports are treated as exported.\\n ///\\n /// Note: Context of used_exports is ignored, as the specifiers comes from\\n /// other module.\\n pub(super) fn optimize(&self, mut node: Module) -> Module {\\n self.run(|| {\\n if !self.config.disable_inliner {\\n node = node.fold_with(&mut constant_propagation())\\n }\\n\\n node = node.fold_with(&mut Repeat::new(dce::dce(dce::Config {\\n // TODO(kdy1): Apply mark to wrapped esms and use it at here.\\n module_mark: None,\\n })));\\n\\n node\\n })\\n }\\n}\\n\",\n", + " 'content_id': '659d9a77d6949869d902f8107c29bf52721bfb27',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 95,\n", + " 'path': '/bundler/src/bundler/optimize.rs',\n", + " 'size': 918,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5016429353778752,\n", + " 'avg_line_length': 26.172619047619047,\n", + " 'blob_id': '18206e9dc29e64f66fbe5b205203b6495b706fc2',\n", + " 'content': '//! Utilities for testing.\\nuse super::{load::TransformedModule, Bundler, Config};\\nuse crate::{load::ModuleData, util::HygieneRemover, Load, ModuleRecord, Resolve};\\nuse anyhow::Error;\\nuse indexmap::IndexMap;\\nuse rustc_hash::FxHasher;\\nuse std::{hash::BuildHasherDefault, path::PathBuf};\\nuse swc_common::{sync::Lrc, FileName, SourceMap, Span, GLOBALS};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_parser::{lexer::Lexer, JscTarget, Parser, StringInput};\\nuse swc_ecma_utils::drop_span;\\nuse swc_ecma_visit::VisitMutWith;\\n\\npub(crate) struct Tester<\\'a> {\\n pub cm: Lrc,\\n pub bundler: Bundler<\\'a, Loader, Resolver>,\\n}\\n\\npub struct Loader {\\n cm: Lrc,\\n files: IndexMap>,\\n}\\n\\nimpl Load for Loader {\\n fn load(&self, f: &FileName) -> Result {\\n eprintln!(\"load: {}\", f);\\n let v = self.files.get(&f.to_string());\\n let v = v.unwrap();\\n\\n let fm = self.cm.new_source_file(f.clone(), v.to_string());\\n\\n let lexer = Lexer::new(\\n Default::default(),\\n JscTarget::Es2020,\\n StringInput::from(&*fm),\\n None,\\n );\\n\\n let mut parser = Parser::new_from(lexer);\\n let module = parser.parse_module().unwrap();\\n\\n Ok(ModuleData {\\n fm,\\n module,\\n helpers: Default::default(),\\n })\\n }\\n}\\n\\n#[derive(Debug, Default)]\\npub struct Resolver;\\n\\nimpl Resolve for Resolver {\\n fn resolve(&self, _: &FileName, s: &str) -> Result {\\n assert!(s.starts_with(\"./\"));\\n\\n let path = PathBuf::from(s.to_string())\\n .with_extension(\"js\")\\n .strip_prefix(\"./\")\\n .unwrap()\\n .into();\\n\\n Ok(FileName::Real(path))\\n }\\n}\\n\\nimpl<\\'a> Tester<\\'a> {\\n pub fn module(&self, name: &str) -> TransformedModule {\\n self.bundler\\n .scope\\n .get_module_by_path(&FileName::Real(name.to_string().into()))\\n .unwrap_or_else(|| panic!(\"failed to find module named {}\", name))\\n }\\n\\n #[allow(dead_code)]\\n pub fn parse(&self, s: &str) -> Module {\\n let fm = self\\n .cm\\n .new_source_file(FileName::Real(PathBuf::from(\"input.js\")), s.into());\\n\\n let lexer = Lexer::new(\\n Default::default(),\\n Default::default(),\\n StringInput::from(&*fm),\\n None,\\n );\\n let mut parser = Parser::new_from(lexer);\\n parser.parse_module().unwrap()\\n }\\n\\n #[allow(dead_code)]\\n pub fn assert_eq(&self, m: &Module, expected: &str) {\\n let expected = self.parse(expected);\\n\\n let mut m = m.clone();\\n m.visit_mut_with(&mut HygieneRemover);\\n\\n let m = drop_span(m);\\n let expected = drop_span(expected);\\n\\n assert_eq!(m, expected)\\n }\\n}\\npub(crate) fn suite() -> TestBuilder {\\n TestBuilder::default()\\n}\\n\\n#[derive(Default)]\\npub(crate) struct TestBuilder {\\n files: IndexMap>,\\n}\\n\\nimpl TestBuilder {\\n pub fn file(mut self, name: &str, src: &str) -> Self {\\n self.files.insert(name.to_string(), src.to_string());\\n self\\n }\\n\\n pub fn run(self, op: F)\\n where\\n F: FnOnce(&mut Tester) -> Result<(), Error>,\\n {\\n testing::run_test2(true, |cm, _| {\\n GLOBALS.with(|globals| {\\n let bundler = Bundler::new(\\n globals,\\n cm.clone(),\\n Loader {\\n cm: cm.clone(),\\n files: self.files.clone(),\\n },\\n Default::default(),\\n Config {\\n require: true,\\n disable_inliner: true,\\n external_modules: vec![],\\n module: Default::default(),\\n },\\n Box::new(Hook),\\n );\\n\\n for (name, _) in self.files {\\n bundler\\n .load_transformed(&FileName::Real(name.clone().into()))\\n .unwrap();\\n }\\n\\n let mut t = Tester {\\n cm: cm.clone(),\\n bundler,\\n };\\n\\n op(&mut t).unwrap();\\n\\n Ok(())\\n })\\n })\\n .expect(\"WTF?\");\\n }\\n}\\n\\nstruct Hook;\\n\\nimpl crate::Hook for Hook {\\n fn get_import_meta_props(&self, _: Span, _: &ModuleRecord) -> Result, Error> {\\n unreachable!()\\n }\\n}\\n',\n", + " 'content_id': '87904d68556c7441d60e4ee1cd4720d981809dbe',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/bundler/src/bundler/tests.rs',\n", + " 'size': 4565,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5655326735990619,\n", + " 'avg_line_length': 15.985569105691058,\n", + " 'blob_id': 'a1369caa4e0232b4a59d984d3b079147c4e5613c',\n", + " 'content': 'use std::{cell::RefCell, path::PathBuf, rc::Rc};\\nuse swc_common::{chain, Mark};\\nuse swc_ecma_parser::{EsConfig, Syntax, TsConfig};\\nuse swc_ecma_transforms_base::{\\n fixer::fixer,\\n helpers::inject_helpers,\\n hygiene::hygiene,\\n resolver::{resolver, resolver_with_mark},\\n};\\nuse swc_ecma_transforms_compat::{\\n es2015::{\\n block_scoped_functions, block_scoping, classes, destructuring, for_of, parameters,\\n regenerator, spread,\\n },\\n es2018::object_rest_spread,\\n};\\nuse swc_ecma_transforms_module::{\\n common_js::common_js,\\n import_analysis::import_analyzer,\\n util::{Config, Lazy, Scope},\\n};\\nuse swc_ecma_transforms_testing::{test, test_exec, test_fixture};\\nuse swc_ecma_visit::Fold;\\n\\nfn syntax() -> Syntax {\\n Syntax::Es(EsConfig {\\n dynamic_import: true,\\n top_level_await: true,\\n ..Default::default()\\n })\\n}\\nfn ts_syntax() -> Syntax {\\n Syntax::Typescript(TsConfig {\\n ..Default::default()\\n })\\n}\\n\\nfn tr(config: Config) -> impl Fold {\\n let mark = Mark::fresh(Mark::root());\\n\\n chain!(resolver_with_mark(mark), common_js(mark, config, None))\\n}\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_369,\\n \"export function input(name) {\\n return `${name}.md?render`;\\n}\\n\\nexport default function({\\n name, input: inp,\\n}) {\\n inp = inp || input(name);\\n return {input: inp};\\n}\",\\n \"\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.input = input;\\nexports.default = _default;\\nfunction input(name) {\\n return `${name}.md?render`;\\n}\\nfunction _default({ name , input: inp }) {\\n inp = inp || input(name);\\n return {\\n input: inp\\n };\\n}\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| common_js(Mark::fresh(Mark::root()), Default::default(), None),\\n issue_389_1,\\n \"\\nimport Foo from \\'foo\\';\\nFoo.bar = true;\\n\",\\n \"\\n\\'use strict\\';\\nvar _foo = _interopRequireDefault(require(\\'foo\\'));\\n_foo.default.bar = true;\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| {\\n let mark = Mark::fresh(Mark::root());\\n\\n let scope = Rc::new(RefCell::new(Scope::default()));\\n chain!(\\n resolver_with_mark(mark),\\n // Optional::new(typescript::strip(), syntax.typescript()),\\n import_analyzer(Rc::clone(&scope)),\\n inject_helpers(),\\n common_js(mark, Default::default(), Some(scope)),\\n hygiene(),\\n fixer(None)\\n )\\n },\\n issue_389_2,\\n \"\\nimport Foo from \\'foo\\';\\nFoo.bar = true;\\n\",\\n \"\\n\\'use strict\\';\\nvar _foo = _interopRequireDefault(require(\\'foo\\'));\\nfunction _interopRequireDefault(obj) {\\n return obj && obj.__esModule ? obj : {\\n default: obj\\n };\\n}\\n_foo.default.bar = true;\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_335,\\n \"import bar from \\'bar\\';\\n\\nobj[bar(\\'bas\\')] = \\'123\\'\",\\n \"\\'use strict\\';\\nvar _bar = _interopRequireDefault(require(\\'bar\\'));\\nobj[(0, _bar).default(\\'bas\\')] = \\'123\\';\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_332,\\n \"import foo from \\'foo\\';\\n\\nexport const bar = { foo }\",\\n \"\\n\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.bar = void 0;\\nvar _foo = _interopRequireDefault(require(\\'foo\\'));\\nconst bar = {\\n foo: _foo.default\\n};\\nexports.bar = bar;\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_326,\\n \"import foo from \\'foo\\';\\nimport bar from \\'../foo\\';\\nfoo, bar\",\\n \"\\'use strict\\';\\nvar _foo = _interopRequireDefault(require(\\'foo\\'));\\nvar _foo1 = _interopRequireDefault(require(\\'../foo\\'));\\n\\n_foo.default, _foo1.default\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_235,\\n \"import {Foo as Bar} from \\'something\\';\\nexport const fn = ({a = new Bar()}) => a;\",\\n \"\\n\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.fn = void 0;\\nvar _something = require(\\'something\\');\\nconst fn = ({ a =new _something.Foo() })=>a\\n;\\nexports.fn = fn;\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n custom_usage,\\n r#\"\\nimport React from \\'react\\'\\nwindow.React = React;\\n \"#,\\n r#\"\\n\\'use strict\\';\\nvar _react = _interopRequireDefault(require(\\'react\\'));\\nwindow.React = _react.default;\\n\"#\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n custom_01,\\n r#\"\\nvar foo = 1;\\nexport var foo = 2;\\nfoo = 3;\\n\"#,\\n r#\"\\n\"use strict\";\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\n\\nexports.foo = void 0;\\nvar foo = 1;\\nvar foo = 2;\\nexports.foo = foo;\\nexports.foo = foo = 3;\\n\\n\"#\\n);\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n custom_02,\\n r#\"\\nexport const good = {\\n a(bad1) {\\n (...bad2) => { };\\n }\\n};\"#,\\n r#\"\\n\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.good = void 0;\\nconst good = {\\n a (bad1) {\\n (...bad2)=>{};\\n }\\n};\\nexports.good = good;\\n\\n\"#\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_176,\\n r#\"\\n\"use strict\";\\n\\nlet x = 4;\"#,\\n r#\"\\n\"use strict\";\\n\\nlet x = 4;\\n\"#\\n);\\n\\n// strict_export_2\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_2,\\n r#\"\\nvar foo;\\nexport { foo as default };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.default = void 0;\\nvar foo;\\nexports.default = foo;\\n\\n\"#\\n);\\n\\n// interop_hoist_function_exports\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_hoist_function_exports,\\n r#\"\\nimport { isEven } from \"./evens\";\\n\\nexport function nextOdd(n) {\\n return isEven(n) ? n + 1 : n + 2;\\n}\\n\\nexport var isOdd = (function (isEven) {\\n return function (n) {\\n return !isEven(n);\\n };\\n})(isEven);\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.nextOdd = nextOdd;\\nexports.isOdd = void 0;\\n\\nvar _evens = require(\"./evens\");\\n\\nfunction nextOdd(n) {\\n return (0, _evens).isEven(n) ? n + 1 : n + 2;\\n}\\n\\nvar isOdd = function (isEven) {\\n return function (n) {\\n return !isEven(n);\\n };\\n}(_evens.isEven);\\n\\nexports.isOdd = isOdd;\\n\\n\"#\\n);\\n\\n// regression_t7199\\n\\n// misc_undefined_this_root_declaration\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n misc_undefined_this_root_declaration,\\n r#\"\\nvar self = this;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar self = void 0;\\n\\n\"#\\n);\\n\\n// interop_export_default_3\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_3,\\n r#\"\\nexport default [];\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\nvar _default = [];\\nexports.default = _default;\\n\\n\"#\\n);\\n\\n// misc_copy_getters_setters\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n misc_copy_getters_setters,\\n r#\"\\nimport Foo, { baz } from \"./moduleWithGetter\";\\n\\nexport { Foo, baz };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"Foo\", {\\n enumerable: true,\\n get: function () {\\n return _moduleWithGetter.default;\\n }\\n});\\nObject.defineProperty(exports, \"baz\", {\\n enumerable: true,\\n get: function () {\\n return _moduleWithGetter.baz;\\n }\\n});\\nvar _moduleWithGetter = _interopRequireWildcard(require(\"./moduleWithGetter\"));\\n\\n\"#\\n);\\n\\n// source_map\\n\\n// regression_t7165\\n\\n// regression_lazy_7176\\n\\n// interop_multi_load\\n\\n// update_expression_positive_suffix\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n update_expression_positive_suffix,\\n r#\"\\nexport let diffLevel = 0;\\n\\nexport function diff() {\\n if (!++diffLevel) {\\n console.log(\"hey\");\\n }\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.diff = diff;\\nexports.diffLevel = void 0;\\nlet diffLevel = 0;\\nexports.diffLevel = diffLevel;\\n\\nfunction diff() {\\n if (!(exports.diffLevel = diffLevel = +diffLevel + 1)) {\\n console.log(\"hey\");\\n }\\n}\\n\\n\"#\\n);\\n\\n// interop_export_default_11\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_11,\\n r#\"\\nexport default new Cachier()\\n\\nexport function Cachier(databaseName) {}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nexports.Cachier = Cachier;\\nexports.default = void 0;\\n\\nvar _default = new Cachier();\\n\\nexports.default = _default;\\n\\nfunction Cachier(databaseName) {}\\n\"#\\n);\\n\\n// interop_export_named_5\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_named_5,\\n r#\"\\nvar foo, bar;\\nexport {foo as default, bar};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.bar = exports.default = void 0;\\nvar foo, bar;\\nexports.default = foo;\\nexports.bar = bar;\\n\\n\"#\\n);\\n\\n// interop_exports_variable\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_exports_variable,\\n r#\"\\nexport var foo = 1;\\nexport var foo2 = 1, bar = 2;\\nexport var foo3 = function () {};\\nexport var foo4;\\nexport let foo5 = 2;\\nexport let foo6;\\nexport const foo7 = 3;\\nexport function foo8 () {}\\nexport class foo9 {}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.foo8 = foo8;\\nexports.foo2 = exports.foo7 = exports.foo3 = exports.foo4 = exports.bar =\\n exports.foo = exports.foo5 = exports.foo6 = void 0;\\n\\nvar foo = 1;\\nexports.foo = foo;\\nvar foo2 = 1, bar = 2;\\nexports.foo2 = foo2;\\nexports.bar = bar;\\n\\nvar foo3 = function () {};\\n\\nexports.foo3 = foo3;\\nvar foo4;\\nexports.foo4 = foo4;\\nlet foo5 = 2;\\nexports.foo5 = foo5;\\nlet foo6;\\nexports.foo6 = foo6;\\nconst foo7 = 3;\\nexports.foo7 = foo7;\\n\\nfunction foo8() {}\\n\\nclass foo9 {}\\nexports.foo9 = foo9;\\n\\n\"#\\n);\\n\\n// interop_export_from_2\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_2,\\n r#\"\\nexport {foo} from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"foo\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo;\\n }\\n});\\n\\nvar _foo = require(\"foo\");\\n\"#\\n);\\n\\n// lazy_local_reexport_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_reexport_default,\\n r#\"\\nimport foo from \"./foo\";\\nexport { foo as default };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"default\", {\\n enumerable: true,\\n get: function () {\\n return _foo.default;\\n }\\n});\\n\\nvar _foo = _interopRequireDefault(require(\"./foo\"));\\n\\n\"#\\n);\\n\\n// lazy_local_reexport_namespace\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_reexport_namespace,\\n r#\"\\nimport * as namespace from \"./foo\";\\nexport { namespace };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.namespace = void 0;\\nvar namespace = _interopRequireWildcard(require(\"./foo\"));\\nexports.namespace = namespace;\\n\\n\"#\\n);\\n\\n// regression_es3_compatibility_function\\n\\n// regression_es3_compatibility_named_function\\n\\n// interop_export_default_6\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_6,\\n r#\"\\nexport default class {}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\n\\nclass _default {}\\n\\nexports.default = _default;\\n\\n\"#\\n);\\n\\n// no_interop_import_default_only\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n no_interop: true,\\n ..Default::default()\\n }),\\n no_interop_import_default_only,\\n r#\"\\nimport foo from \"foo\";\\n\\nfoo();\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = require(\"foo\");\\n\\n(0, _foo).default();\\n\\n\"#\\n);\\n\\n// regression_4462_T7565\\n\\n// interop_export_from_7\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_7,\\n r#\"\\nexport {default as foo} from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"foo\", {\\n enumerable: true,\\n get: function () {\\n return _foo.default;\\n }\\n});\\n\\nvar _foo = _interopRequireDefault(require(\"foo\"));\\n\\n\"#\\n);\\n\\n// interop_remap\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_remap,\\n r#\"\\nexport var test = 2;\\ntest = 5;\\ntest++;\\n\\n(function () {\\n var test = 2;\\n test = 3;\\n test++;\\n})();\\n\\nvar a = 2;\\nexport { a };\\na = 3;\\n\\nvar b = 2;\\nexport { b as c };\\nb = 3;\\n\\nvar d = 3;\\nexport { d as e, d as f };\\nd = 4;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.e = exports.c = exports.a = exports.test = exports.f = void 0;\\nvar test = 2;\\nexports.test = test;\\nexports.test = test = 5;\\nexports.test = test = +test + 1;\\n\\n(function () {\\n var test = 2;\\n test = 3;\\n test++;\\n})();\\n\\nvar a = 2;\\nexports.a = a;\\nexports.a = a = 3;\\nvar b = 2;\\nexports.c = b;\\nexports.c = b = 3;\\nvar d = 3;\\nexports.e = d;\\nexports.f = d;\\nexports.f = exports.e = d = 4;\\n\\n\"#\\n);\\n\\n// regression_es3_compatibility_class\\n\\n// lazy_dep_reexport_all\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_reexport_all,\\n r#\"\\nexport * from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nvar _foo = require(\"foo\");\\n\\nObject.keys(_foo).forEach(function (key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (key in exports && exports[key] === _foo[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function () {\\n return _foo[key];\\n }\\n });\\n});\\n\\n\"#\\n);\\n\\n// misc_copy_getters_setters_star\\n\\n// regression_t7160\\n\\n// lazy_local_sideeffect\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_sideeffect,\\n r#\"\\nimport \"./a\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nrequire(\"./a\");\\n\\n\"#\\n);\\n\\n// strict_export_const_destructuring_deep\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_const_destructuring_deep,\\n r#\"\\nexport const { foo: { bar: [baz, qux] } } = {};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.qux = exports.baz = void 0;\\nconst {\\n foo: {\\n bar: [baz, qux]\\n }\\n} = {};\\nexports.baz = baz;\\nexports.qux = qux;\\n\\n\"#\\n);\\n\\n// lazy_local_reexport_all\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_reexport_all,\\n r#\"\\nexport * from \"./foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nvar _foo = require(\"./foo\");\\n\\nObject.keys(_foo).forEach(function (key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (key in exports && exports[key] === _foo[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function () {\\n return _foo[key];\\n }\\n });\\n});\\n\\n\"#\\n);\\n\\n// interop_illegal_export_esmodule_2\\n\\n// interop_export_from_4\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_4,\\n r#\"\\nexport {foo as bar} from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"bar\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo;\\n }\\n});\\n\\nvar _foo = require(\"foo\");\\n\\n\"#\\n);\\n\\n// interop_export_destructured\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_destructured,\\n r#\"\\nexport let x = 0;\\nexport let y = 0;\\n\\nexport function f1 () {\\n ({x} = { x: 1 });\\n}\\n\\nexport function f2 () {\\n ({x, y} = { x: 2, y: 3 });\\n}\\n\\nexport function f3 () {\\n [x, y, z] = [3, 4, 5]\\n}\\n\\nexport function f4 () {\\n [x, , y] = [3, 4, 5]\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.f1 = f1;\\nexports.f2 = f2;\\nexports.f3 = f3;\\nexports.f4 = f4;\\nexports.y = exports.x = void 0;\\nlet x = 0;\\nexports.x = x;\\nlet y = 0;\\nexports.y = y;\\n\\nfunction f1() {\\n ({\\n x\\n } = {\\n x: 1\\n }), exports.x = x;\\n}\\n\\nfunction f2() {\\n ({\\n x,\\n y\\n } = {\\n x: 2,\\n y: 3\\n }), exports.x = x, exports.y = y;\\n}\\n\\nfunction f3() {\\n [x, y, z] = [3, 4, 5], exports.x = x, exports.y = y;\\n}\\n\\nfunction f4() {\\n [x,, y] = [3, 4, 5], exports.x = x, exports.y = y;\\n}\\n\\n\"#\\n);\\n\\n// strict_export_const_destructuring_array\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_const_destructuring_array,\\n r#\"\\nexport const [foo, bar] = [];\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.bar = exports.foo = void 0;\\nconst [foo, bar] = [];\\nexports.foo = foo;\\nexports.bar = bar;\\n\\n\"#\\n);\\n\\n// interop_export_named_3\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_named_3,\\n r#\"\\nvar foo;\\nexport {foo as bar};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.bar = void 0;\\nvar foo;\\nexports.bar = foo;\\n\\n\"#\\n);\\n\\n// strict_import_source\\n\\n// interop_imports_glob\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_imports_glob,\\n r#\"\\nimport * as foo from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar foo = _interopRequireWildcard(require(\"foo\"));\\n\\n\"#\\n);\\n\\n// misc\\n\\n// strict_export_all\\n\\n// strict_export\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export,\\n r#\"\\nexport function foo() {}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.foo = foo;\\n\\nfunction foo() {}\\n\\n\"#\\n);\\n\\n// no_interop_import_wildcard\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n no_interop: true,\\n ..Default::default()\\n }),\\n no_interop_import_wildcard,\\n r#\"\\nimport * as foo from \\'foo\\';\\n\\nfoo.bar();\\nfoo.baz();\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar foo = require(\"foo\");\\n\\nfoo.bar();\\nfoo.baz();\\n\\n\"#\\n);\\n\\n// interop_export_default_5\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_5,\\n r#\"\\nexport default function () {}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nexports.default = _default;\\nfunction _default() {}\\n\\n\"#\\n);\\n\\n// strict_export_const_destructuring_object_default_params\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_const_destructuring_object_default_params,\\n r#\"\\nexport const { foo, bar = 1 } = {};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.bar = exports.foo = void 0;\\nconst {\\n foo,\\n bar = 1\\n} = {};\\nexports.foo = foo;\\nexports.bar = bar;\\n\\n\"#\\n);\\n\\n// lazy_whitelist_reexport_all\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_reexport_all,\\n r#\"\\nexport * from \"white\";\\n\\nexport * from \"black\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nvar _exportNames = {\\n};\\n\\nvar _white = require(\"white\");\\nvar _black = require(\"black\");\\n\\nObject.keys(_white).forEach(function (key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\\n if (key in exports && exports[key] === _white[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function () {\\n return _white[key];\\n }\\n });\\n});\\n\\nObject.keys(_black).forEach(function (key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\\n if (key in exports && exports[key] === _black[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function () {\\n return _black[key];\\n }\\n });\\n});\\n\\n\"#\\n);\\n\\n// misc_reference_source_map\\n\\n// lazy_dep_import_namespace\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_import_namespace,\\n r#\"\\nimport * as foo from \"foo\";\\n\\nfunction use() {\\n console.log(foo);\\n}\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nfunction foo() {\\n const data = _interopRequireWildcard(require(\"foo\"));\\n\\n foo = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\nfunction use() {\\n console.log(foo());\\n}\\n\\n\"#\\n);\\n\\n// lazy_whitelist_reexport_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_reexport_default,\\n r#\"\\nimport foo from \"white\";\\nexport { foo as default };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"default\", {\\n enumerable: true,\\n get: function () {\\n return _white().default;\\n }\\n});\\n\\nfunction _white() {\\n const data = _interopRequireDefault(require(\"white\"));\\n _white = function() {\\n return data;\\n };\\n return data;\\n}\\n\\n\"#\\n);\\n\\n// misc_local_exports_decl\\n\\n// interop_export_default_8\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_8,\\n r#\"\\nexport default class Foo {}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\n\\nclass Foo {}\\n\\nexports.default = Foo;\\n\\n\"#\\n);\\n\\n// strict_export_1\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_1,\\n r#\"\\nexport default foo;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.default = void 0;\\nvar _default = foo;\\nexports.default = _default;\\n\\n\"#\\n);\\n\\n// lazy_local_import_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_import_named,\\n r#\"\\nimport { foo } from \"./foo\";\\n\\nconsole.log(foo);\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = require(\"./foo\");\\n\\nconsole.log(_foo.foo);\\n\\n\"#\\n);\\n\\n// interop_export_default_2\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_2,\\n r#\"\\nexport default {};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\nvar _default = {};\\nexports.default = _default;\\n\\n\"#\\n);\\n\\n// interop_export_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_named_1,\\n r#\"\\nvar foo;\\nexport {foo};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.foo = void 0;\\nvar foo;\\nexports.foo = foo;\\n\\n\"#\\n);\\n\\n// interop_imports_ordering\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_imports_ordering,\\n r#\"\\nimport \\'./foo\\';\\nimport bar from \\'./bar\\';\\nimport \\'./derp\\';\\nimport { qux } from \\'./qux\\';\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nrequire(\"./foo\");\\n\\nvar _bar = _interopRequireDefault(require(\"./bar\"));\\n\\nrequire(\"./derp\");\\n\\nvar _qux = require(\"./qux\");\\n\\n\"#\\n);\\n\\n// strict_export_3\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_3,\\n r#\"\\nexport {};\\n\\nexport {} from \\'foo\\';\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nrequire(\"foo\");\\n\\n\"#\\n);\\n\\n// interop_export_named_4\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_named_4,\\n r#\"\\nvar foo;\\nexport {foo as default};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\nvar foo;\\nexports.default = foo;\\n\\n\"#\\n);\\n\\n// misc_import_const_throw\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n misc_import_const_throw,\\n r#\"\\nimport Foo from \"foo\";\\n\\nimport * as Bar from \"bar\";\\n\\nimport { Baz } from \"baz\";\\n\\nFoo = 42;\\nBar = 43;\\nBaz = 44;\\n\\n({Foo} = {});\\n({Bar} = {});\\n({Baz} = {});\\n\\n({prop: Foo} = {});\\n({prop: Bar} = {});\\n({prop: Baz} = {});\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = _interopRequireDefault(require(\"foo\"));\\n\\nvar Bar = _interopRequireWildcard(require(\"bar\"));\\n\\nvar _baz = require(\"baz\");\\n\\n_foo.default = (42, (function() {\\n throw new Error(\\'\"\\' + \\'Foo\\' + \\'\" is read-only.\\');\\n})());\\nBar = (43, (function() {\\n throw new Error(\\'\"\\' + \\'Bar\\' + \\'\" is read-only.\\');\\n})());\\n_baz.Baz = (44, (function() {\\n throw new Error(\\'\"\\' + \\'Baz\\' + \\'\" is read-only.\\');\\n})());\\n({ Foo } = ( {\\n}, (function() {\\n throw new Error(\\'\"\\' + \\'Foo\\' + \\'\" is read-only.\\');\\n})()));\\n({ Bar } = ( {\\n}, (function() {\\n throw new Error(\\'\"\\' + \\'Bar\\' + \\'\" is read-only.\\');\\n})()));\\n({ Baz } = ( {\\n}, (function() {\\n throw new Error(\\'\"\\' + \\'Baz\\' + \\'\" is read-only.\\');\\n})()));\\n({ prop: Foo } = ( {\\n}, (function() {\\n throw new Error(\\'\"\\' + \\'Foo\\' + \\'\" is read-only.\\');\\n})()));\\n({ prop: Bar } = ( {\\n}, (function() {\\n throw new Error(\\'\"\\' + \\'Bar\\' + \\'\" is read-only.\\');\\n})()));\\n({ prop: Baz } = ( {\\n}, (function() {\\n throw new Error(\\'\"\\' + \\'Baz\\' + \\'\" is read-only.\\');\\n})()));\\n\\n\\n\"#\\n);\\n\\n// lazy_local_import_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_import_default,\\n r#\"\\nimport foo from \"./foo\";\\n\\nconsole.log(foo);\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = _interopRequireDefault(require(\"./foo\"));\\n\\nconsole.log(_foo.default);\\n\\n\"#\\n);\\n\\n// lazy_whitelist_reexport_namespace\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_reexport_namespace,\\n r#\"\\nimport * as namespace1 from \"white\";\\nexport { namespace1 };\\n\\nimport * as namespace2 from \"black\";\\nexport { namespace2 };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nObject.defineProperty(exports, \"namespace1\", {\\n enumerable: true,\\n get: function () {\\n return namespace1();\\n }\\n});\\n\\nexports.namespace2 = void 0;\\nfunction namespace1() {\\n const data = _interopRequireWildcard(require(\"white\"));\\n\\n namespace1 = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\n\\nvar namespace2 = _interopRequireWildcard(require(\"black\"));\\nexports.namespace2 = namespace2;\\n\\n\"#\\n);\\n\\n// interop_export_from_3\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_3,\\n r#\"\\nexport {foo, bar} from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"foo\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo;\\n }\\n});\\nObject.defineProperty(exports, \"bar\", {\\n enumerable: true,\\n get: function () {\\n return _foo.bar;\\n }\\n});\\n\\nvar _foo = require(\"foo\");\\n\\n\"#\\n);\\n\\n// lazy_dep_reexport_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_reexport_named,\\n r#\"\\nimport { named } from \"foo\";\\nexport { named };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nObject.defineProperty(exports, \"named\", {\\n enumerable: true,\\n get: function () {\\n return _foo().named;\\n }\\n});\\nfunction _foo() {\\n const data = require(\"foo\");\\n\\n _foo = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\n\\n\"#\\n);\\n\\n// auxiliary_comment_overview\\ntest!(\\n // Comment is not supported yet\\n ignore,\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n auxiliary_comment_overview,\\n r#\"\\nimport \"foo\";\\nimport \"foo-bar\";\\nimport \"./directory/foo-bar\";\\nimport foo from \"foo2\";\\nimport * as foo2 from \"foo3\";\\nimport {bar} from \"foo4\";\\nimport {foo as bar2} from \"foo5\";\\n\\nvar test;\\nexport {test};\\nexport var test2 = 5;\\n\\nbar(foo, bar2);\\n\\n/* my comment */\\nbar2;\\nfoo;\\n\\n\"#,\\n r#\"\\n/*before*/\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.test2 = exports.test = void 0;\\n\\n/*after*/\\n\\n/*before*/\\nrequire(\"foo\")\\n/*after*/\\n;\\n\\n/*before*/\\nrequire(\"foo-bar\")\\n/*after*/\\n;\\n\\n/*before*/\\nrequire(\"./directory/foo-bar\")\\n/*after*/\\n;\\n\\nvar\\n/*before*/\\n_foo2 = _interopRequireDefault(require(\"foo2\"))\\n/*after*/\\n;\\n\\nvar\\n/*before*/\\nfoo2 = _interopRequireDefault(require(\"foo3\"))\\n/*after*/\\n;\\n\\nvar\\n/*before*/\\n_foo4 = require(\"foo4\")\\n/*after*/\\n;\\n\\nvar\\n/*before*/\\n_foo5 = require(\"foo5\")\\n/*after*/\\n;\\n\\nvar test;\\n\\n/*before*/\\nexports.test = test;\\n\\n/*after*/\\nvar test2 = 5;\\n\\n/*before*/\\nexports.test2 = test2;\\n\\n/*after*/\\n\\n/*before*/\\n(0,\\n/*after*/\\n\\n/*before*/\\n_foo4\\n/*after*/\\n.\\n/*before*/\\nbar)\\n/*after*/\\n(\\n/*before*/\\n_foo2\\n/*after*/\\n.\\n/*before*/\\ndefault\\n/*after*/\\n,\\n/*before*/\\n_foo5\\n/*after*/\\n.\\n/*before*/\\nfoo\\n/*after*/\\n);\\n/* my comment */\\n\\n/*before*/\\n_foo5\\n/*after*/\\n.\\n/*before*/\\nfoo\\n/*after*/\\n;\\n\\n/*before*/\\n_foo2\\n/*after*/\\n.\\n/*before*/\\ndefault\\n/*after*/\\n;\\n\\n\"#\\n);\\n\\n// misc_module_exports\\n\\n// interop_imports_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_imports_default,\\n r#\"\\nimport foo from \"foo\";\\nimport {default as foo2} from \"foo\";\\n\\nfoo;\\nfoo2;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = _interopRequireDefault(require(\"foo\"));\\n\\n_foo.default;\\n_foo.default;\\n\\n\"#\\n);\\n\\n// misc_undefined_this_root_reference\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n misc_undefined_this_root_reference,\\n r#\"\\nthis;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvoid 0;\\n\\n\"#\\n);\\n\\n// regression_t7272\\n\\n// interop_export_default_10\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_10,\\n r#\"\\nexport default (function(){return \"foo\"})();\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\n\\nvar _default = function () {\\n return \"foo\";\\n}();\\n\\nexports.default = _default;\\n\\n\"#\\n);\\n\\n// lazy_whitelist_import_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_import_named,\\n r#\"\\nimport { foo1 } from \"white\";\\n\\nfunction use1() {\\n console.log(foo1);\\n}\\n\\nimport { foo2 } from \"black\";\\n\\nfunction use2() {\\n console.log(foo2);\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nfunction _white() {\\n const data = require(\"white\");\\n\\n _white = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\nvar _black = require(\"black\");\\n\\nfunction use1() {\\n console.log(_white().foo1);\\n}\\nfunction use2() {\\n console.log(_black.foo2);\\n}\\n\\n\"#\\n);\\n\\n// interop_export_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default,\\n r#\"\\nexport default 42;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\nvar _default = 42;\\nexports.default = _default;\\n\\n\"#\\n);\\n\\n// strict\\n\\n// lazy_local_import_namespace\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_import_namespace,\\n r#\"\\nimport * as foo from \"./foo\";\\n\\nconsole.log(foo);\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar foo = _interopRequireWildcard(require(\"./foo\"));\\nconsole.log(foo);\\n\\n\"#\\n);\\n\\n// interop\\n\\n// interop_export_default_7\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_7,\\n r#\"\\nexport default function foo () {}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nexports.default = foo;\\n\\nfunction foo() {}\\n\\n\"#\\n);\\n\\n// lazy_whitelist_reexport_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_reexport_named,\\n r#\"\\nimport { named1 } from \"white\";\\nexport { named1 };\\n\\nimport { named2 } from \"black\";\\nexport { named2 };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"named1\", {\\n enumerable: true,\\n get: function () {\\n return _white().named1;\\n }\\n});\\nObject.defineProperty(exports, \"named2\", {\\n enumerable: true,\\n get: function () {\\n return _black.named2;\\n }\\n});\\n\\nfunction _white() {\\n const data = require(\"white\");\\n\\n _white = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\nvar _black = require(\"black\");\\n\\n\\n\"#\\n);\\n\\n// lazy_dep\\n\\n// interop_export_from\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_1,\\n r#\"\\nexport * from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nvar _foo = require(\"foo\");\\n\\nObject.keys(_foo).forEach(function (key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (key in exports && exports[key] === _foo[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function () {\\n return _foo[key];\\n }\\n });\\n});\\n\\n\"#\\n);\\n\\n// disable_strict_mode_strict_mode_false\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict_mode: false,\\n ..Default::default()\\n }),\\n disable_strict_mode_strict_mode_false,\\n r#\"\\nimport \"foo\";\\nimport \"foo-bar\";\\nimport \"./directory/foo-bar\";\\n\\n\"#,\\n r#\"\\nrequire(\"foo\");\\n\\nrequire(\"foo-bar\");\\n\\nrequire(\"./directory/foo-bar\");\\n\\n\"#\\n);\\n\\n// interop_export_from_6\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_6,\\n r#\"\\nexport {foo as default, bar} from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"default\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo;\\n }\\n});\\nObject.defineProperty(exports, \"bar\", {\\n enumerable: true,\\n get: function () {\\n return _foo.bar;\\n }\\n});\\n\\nvar _foo = require(\"foo\");\\n\\n\"#\\n);\\n\\n// interop_export_from_5\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_5,\\n r#\"\\nexport {foo as default} from \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"default\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo;\\n }\\n});\\n\\nvar _foo = require(\"foo\");\\n\\n\"#\\n);\\n\\n// strict_import\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_import,\\n r#\"\\nimport foo from \"foo\";\\nimport { default as foo2 } from \"foo\";\\nimport { foo3 } from \"foo\";\\nimport * as foo4 from \"foo\";\\n\\nfoo;\\nfoo2;\\nfoo3;\\nfoo3();\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar foo4 = _interopRequireWildcard(require(\"foo\"));\\nfoo4.default;\\nfoo4.default;\\nfoo4.foo3;\\n(0, foo4).foo3();\\n\\n\"#\\n);\\n\\n// interop_export_named_2\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_named_2,\\n r#\"\\nvar foo, bar;\\nexport {foo, bar};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.bar = exports.foo = void 0;\\nvar foo, bar;\\nexports.foo = foo;\\nexports.bar = bar;\\n\\n\"#\\n);\\n\\n// lazy_whitelist_import_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_import_default,\\n r#\"\\nimport foo1 from \"white\";\\n\\nconsole.log(foo1);\\n\\nimport foo2 from \"black\";\\n\\nconsole.log(foo2);\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _white = _interopRequireDefault(require(\"white\"));\\nvar _black = _interopRequireDefault(require(\\'black\\'));\\n\\nconsole.log(_white.default);\\nconsole.log(_black.default);\\n\\n\"#\\n);\\n\\n// interop_imports\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_imports,\\n r#\"\\nimport \"foo\";\\nimport \"foo-bar\";\\nimport \"./directory/foo-bar\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nrequire(\"foo\");\\n\\nrequire(\"foo-bar\");\\n\\nrequire(\"./directory/foo-bar\");\\n\\n\"#\\n);\\n\\n// lazy_local\\n\\n// strict_export_const_destructuring_object\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_const_destructuring_object,\\n r#\"\\nexport const { foo: bar, baz } = {};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.baz = exports.bar = void 0;\\nconst {\\n foo: bar,\\n baz\\n} = {};\\nexports.bar = bar;\\nexports.baz = baz;\\n\\n\"#\\n);\\n\\n// regression_issue_9155\\n\\n// update_expression_negative_suffix\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n update_expression_negative_suffix,\\n r#\"\\nexport let diffLevel = 0;\\n\\nexport function diff() {\\n if (!--diffLevel) {\\n console.log(\"hey\");\\n }\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.diff = diff;\\nexports.diffLevel = void 0;\\nlet diffLevel = 0;\\nexports.diffLevel = diffLevel;\\n\\nfunction diff() {\\n if (!(exports.diffLevel = diffLevel = +diffLevel - 1)) {\\n console.log(\"hey\");\\n }\\n}\\n\\n\"#\\n);\\n\\n// interop_module_shadow\\ntest!(\\n // TODO(kdy1): Unignore this\\n ignore,\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_module_shadow,\\n r#\"\\nexport function module() {\\n\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.module = _module;\\n\\nfunction _module() {}\\n\\n\"#\\n);\\n\\n// strict_export_const_destructuring_object_rest\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_const_destructuring_object_rest,\\n r#\"\\nexport const { foo, ...bar } = {};\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.bar = exports.foo = void 0;\\nconst {\\n foo,\\n ...bar\\n} = {};\\nexports.foo = foo;\\nexports.bar = bar;\\n\\n\"#\\n);\\n\\n// lazy_whitelist_sideeffect\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_sideeffect,\\n r#\"\\nimport \"white\";\\nimport \"black\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nrequire(\"white\");\\n\\nrequire(\"black\");\\n\\n\"#\\n);\\n\\n// lazy_dep_reexport_namespace\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_reexport_namespace,\\n r#\"\\nimport * as namespace from \"foo\";\\nexport { namespace };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"namespace\", {\\n enumerable: true,\\n get: function () {\\n return namespace();\\n }\\n});\\n\\nfunction namespace() {\\n const data = _interopRequireWildcard(require(\"foo\"));\\n\\n namespace = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\n\\n\"#\\n);\\n\\n// interop_export_default_4\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_4,\\n r#\"\\nexport default foo;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\nvar _default = foo;\\nexports.default = _default;\\n\\n\"#\\n);\\n\\n// no_interop_export_from\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n no_interop: true,\\n ..Default::default()\\n }),\\n no_interop_export_from,\\n r#\"\\nexport { default } from \\'foo\\';\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nObject.defineProperty(exports, \"default\", {\\n enumerable: true,\\n get: function () {\\n return _foo.default;\\n }\\n});\\nvar _foo = require(\"foo\");\\n\\n\"#\\n);\\n\\n// regression_es3_compatibility\\n\\n// lazy_dep_sideeffect\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_sideeffect,\\n r#\"\\nimport \"foo\";\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nrequire(\"foo\");\\n\\n\"#\\n);\\n\\n// interop_export_from_8\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_from_8,\\n r#\"\\nimport { foo, foo1, foo2, foo3, foo4, foo5, foo6, foo7, foo8, foo9, foo10, foo11, foo12,\\n foo13, foo14, foo15, foo16, foo17, foo18, foo19, foo20, foo21, foo22, foo23, foo24, foo25,\\n foo26, foo27, foo28, foo29, foo30, foo31, foo32, foo33, foo34, foo35, foo36, foo37, foo38,\\n foo39, foo40, foo41, foo42, foo43, foo44, foo45, foo46, foo47, foo48, foo49, foo50, foo51,\\n foo52, foo53, foo54, foo55, foo56, foo57, foo58, foo59, foo60, foo61, foo62, foo63, foo64,\\n foo65, foo66, foo67, foo68, foo69, foo70, foo71, foo72, foo73, foo74, foo75, foo76, foo77,\\n foo78, foo79, foo80, foo81, foo82, foo83, foo84, foo85, foo86, foo87, foo88, foo89, foo90,\\n foo91, foo92, foo93, foo94, foo95, foo96, foo97, foo98, foo99, foo100 } from \"foo\";\\nexport { foo, foo1, foo2, foo3, foo4, foo5, foo6, foo7, foo8, foo9, foo10, foo11, foo12,\\n foo13, foo14, foo15, foo16, foo17, foo18, foo19, foo20, foo21, foo22, foo23, foo24, foo25,\\n foo26, foo27, foo28, foo29, foo30, foo31, foo32, foo33, foo34, foo35, foo36, foo37, foo38,\\n foo39, foo40, foo41, foo42, foo43, foo44, foo45, foo46, foo47, foo48, foo49, foo50, foo51,\\n foo52, foo53, foo54, foo55, foo56, foo57, foo58, foo59, foo60, foo61, foo62, foo63, foo64,\\n foo65, foo66, foo67, foo68, foo69, foo70, foo71, foo72, foo73, foo74, foo75, foo76, foo77,\\n foo78, foo79, foo80, foo81, foo82, foo83, foo84, foo85, foo86, foo87, foo88, foo89, foo90,\\n foo91, foo92, foo93, foo94, foo95, foo96, foo97, foo98, foo99, foo100 }\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"foo\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo;\\n }\\n});\\nObject.defineProperty(exports, \"foo1\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo1;\\n }\\n});\\nObject.defineProperty(exports, \"foo2\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo2;\\n }\\n});\\nObject.defineProperty(exports, \"foo3\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo3;\\n }\\n});\\nObject.defineProperty(exports, \"foo4\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo4;\\n }\\n});\\nObject.defineProperty(exports, \"foo5\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo5;\\n }\\n});\\nObject.defineProperty(exports, \"foo6\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo6;\\n }\\n});\\nObject.defineProperty(exports, \"foo7\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo7;\\n }\\n});\\nObject.defineProperty(exports, \"foo8\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo8;\\n }\\n});\\nObject.defineProperty(exports, \"foo9\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo9;\\n }\\n});\\nObject.defineProperty(exports, \"foo10\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo10;\\n }\\n});\\nObject.defineProperty(exports, \"foo11\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo11;\\n }\\n});\\nObject.defineProperty(exports, \"foo12\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo12;\\n }\\n});\\nObject.defineProperty(exports, \"foo13\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo13;\\n }\\n});\\nObject.defineProperty(exports, \"foo14\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo14;\\n }\\n});\\nObject.defineProperty(exports, \"foo15\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo15;\\n }\\n});\\nObject.defineProperty(exports, \"foo16\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo16;\\n }\\n});\\nObject.defineProperty(exports, \"foo17\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo17;\\n }\\n});\\nObject.defineProperty(exports, \"foo18\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo18;\\n }\\n});\\nObject.defineProperty(exports, \"foo19\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo19;\\n }\\n});\\nObject.defineProperty(exports, \"foo20\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo20;\\n }\\n});\\nObject.defineProperty(exports, \"foo21\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo21;\\n }\\n});\\nObject.defineProperty(exports, \"foo22\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo22;\\n }\\n});\\nObject.defineProperty(exports, \"foo23\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo23;\\n }\\n});\\nObject.defineProperty(exports, \"foo24\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo24;\\n }\\n});\\nObject.defineProperty(exports, \"foo25\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo25;\\n }\\n});\\nObject.defineProperty(exports, \"foo26\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo26;\\n }\\n});\\nObject.defineProperty(exports, \"foo27\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo27;\\n }\\n});\\nObject.defineProperty(exports, \"foo28\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo28;\\n }\\n});\\nObject.defineProperty(exports, \"foo29\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo29;\\n }\\n});\\nObject.defineProperty(exports, \"foo30\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo30;\\n }\\n});\\nObject.defineProperty(exports, \"foo31\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo31;\\n }\\n});\\nObject.defineProperty(exports, \"foo32\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo32;\\n }\\n});\\nObject.defineProperty(exports, \"foo33\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo33;\\n }\\n});\\nObject.defineProperty(exports, \"foo34\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo34;\\n }\\n});\\nObject.defineProperty(exports, \"foo35\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo35;\\n }\\n});\\nObject.defineProperty(exports, \"foo36\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo36;\\n }\\n});\\nObject.defineProperty(exports, \"foo37\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo37;\\n }\\n});\\nObject.defineProperty(exports, \"foo38\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo38;\\n }\\n});\\nObject.defineProperty(exports, \"foo39\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo39;\\n }\\n});\\nObject.defineProperty(exports, \"foo40\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo40;\\n }\\n});\\nObject.defineProperty(exports, \"foo41\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo41;\\n }\\n});\\nObject.defineProperty(exports, \"foo42\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo42;\\n }\\n});\\nObject.defineProperty(exports, \"foo43\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo43;\\n }\\n});\\nObject.defineProperty(exports, \"foo44\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo44;\\n }\\n});\\nObject.defineProperty(exports, \"foo45\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo45;\\n }\\n});\\nObject.defineProperty(exports, \"foo46\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo46;\\n }\\n});\\nObject.defineProperty(exports, \"foo47\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo47;\\n }\\n});\\nObject.defineProperty(exports, \"foo48\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo48;\\n }\\n});\\nObject.defineProperty(exports, \"foo49\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo49;\\n }\\n});\\nObject.defineProperty(exports, \"foo50\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo50;\\n }\\n});\\nObject.defineProperty(exports, \"foo51\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo51;\\n }\\n});\\nObject.defineProperty(exports, \"foo52\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo52;\\n }\\n});\\nObject.defineProperty(exports, \"foo53\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo53;\\n }\\n});\\nObject.defineProperty(exports, \"foo54\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo54;\\n }\\n});\\nObject.defineProperty(exports, \"foo55\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo55;\\n }\\n});\\nObject.defineProperty(exports, \"foo56\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo56;\\n }\\n});\\nObject.defineProperty(exports, \"foo57\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo57;\\n }\\n});\\nObject.defineProperty(exports, \"foo58\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo58;\\n }\\n});\\nObject.defineProperty(exports, \"foo59\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo59;\\n }\\n});\\nObject.defineProperty(exports, \"foo60\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo60;\\n }\\n});\\nObject.defineProperty(exports, \"foo61\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo61;\\n }\\n});\\nObject.defineProperty(exports, \"foo62\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo62;\\n }\\n});\\nObject.defineProperty(exports, \"foo63\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo63;\\n }\\n});\\nObject.defineProperty(exports, \"foo64\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo64;\\n }\\n});\\nObject.defineProperty(exports, \"foo65\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo65;\\n }\\n});\\nObject.defineProperty(exports, \"foo66\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo66;\\n }\\n});\\nObject.defineProperty(exports, \"foo67\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo67;\\n }\\n});\\nObject.defineProperty(exports, \"foo68\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo68;\\n }\\n});\\nObject.defineProperty(exports, \"foo69\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo69;\\n }\\n});\\nObject.defineProperty(exports, \"foo70\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo70;\\n }\\n});\\nObject.defineProperty(exports, \"foo71\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo71;\\n }\\n});\\nObject.defineProperty(exports, \"foo72\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo72;\\n }\\n});\\nObject.defineProperty(exports, \"foo73\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo73;\\n }\\n});\\nObject.defineProperty(exports, \"foo74\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo74;\\n }\\n});\\nObject.defineProperty(exports, \"foo75\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo75;\\n }\\n});\\nObject.defineProperty(exports, \"foo76\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo76;\\n }\\n});\\nObject.defineProperty(exports, \"foo77\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo77;\\n }\\n});\\nObject.defineProperty(exports, \"foo78\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo78;\\n }\\n});\\nObject.defineProperty(exports, \"foo79\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo79;\\n }\\n});\\nObject.defineProperty(exports, \"foo80\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo80;\\n }\\n});\\nObject.defineProperty(exports, \"foo81\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo81;\\n }\\n});\\nObject.defineProperty(exports, \"foo82\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo82;\\n }\\n});\\nObject.defineProperty(exports, \"foo83\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo83;\\n }\\n});\\nObject.defineProperty(exports, \"foo84\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo84;\\n }\\n});\\nObject.defineProperty(exports, \"foo85\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo85;\\n }\\n});\\nObject.defineProperty(exports, \"foo86\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo86;\\n }\\n});\\nObject.defineProperty(exports, \"foo87\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo87;\\n }\\n});\\nObject.defineProperty(exports, \"foo88\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo88;\\n }\\n});\\nObject.defineProperty(exports, \"foo89\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo89;\\n }\\n});\\nObject.defineProperty(exports, \"foo90\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo90;\\n }\\n});\\nObject.defineProperty(exports, \"foo91\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo91;\\n }\\n});\\nObject.defineProperty(exports, \"foo92\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo92;\\n }\\n});\\nObject.defineProperty(exports, \"foo93\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo93;\\n }\\n});\\nObject.defineProperty(exports, \"foo94\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo94;\\n }\\n});\\nObject.defineProperty(exports, \"foo95\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo95;\\n }\\n});\\nObject.defineProperty(exports, \"foo96\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo96;\\n }\\n});\\nObject.defineProperty(exports, \"foo97\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo97;\\n }\\n});\\nObject.defineProperty(exports, \"foo98\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo98;\\n }\\n});\\nObject.defineProperty(exports, \"foo99\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo99;\\n }\\n});\\nObject.defineProperty(exports, \"foo100\", {\\n enumerable: true,\\n get: function () {\\n return _foo.foo100;\\n }\\n});\\n\\nvar _foo = require(\"foo\");\\n\\n\"#\\n);\\n\\n// strict_export_const_destructuring_array_default_params\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_const_destructuring_array_default_params,\\n r#\"\\nexport const [foo, bar = 2] = [];\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.bar = exports.foo = void 0;\\nconst [foo, bar = 2] = [];\\nexports.foo = foo;\\nexports.bar = bar;\\n\\n\"#\\n);\\n\\n// interop_imports_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_imports_named,\\n r#\"\\nimport {bar} from \"foo\";\\nimport {bar2, baz} from \"foo\";\\nimport {bar as baz2} from \"foo\";\\nimport {bar as baz3, xyz} from \"foo\";\\n\\nbar;\\nbar2;\\nbaz;\\nbaz2;\\nbaz3;\\nxyz;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = require(\"foo\");\\n\\n_foo.bar;\\n_foo.bar2;\\n_foo.baz;\\n_foo.bar;\\n_foo.bar;\\n_foo.xyz;\\n\\n\"#\\n);\\n\\n// regression_es3_compatibility_named_class\\n\\n// disable_strict_mode\\n\\n// lazy_whitelist_import_namespace\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::List(vec![\"white\".into()]),\\n ..Default::default()\\n }),\\n lazy_whitelist_import_namespace,\\n r#\"\\nimport * as foo1 from \"white\";\\n\\nfunction use1(){\\n console.log(foo1);\\n}\\n\\nimport * as foo2 from \"black\";\\n\\nfunction use2(){\\n console.log(foo2);\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nfunction foo1() {\\n const data = _interopRequireWildcard(require(\"white\"));\\n\\n foo1 = function () {\\n return data;\\n };\\n\\n return data;\\n}\\nvar foo2 = _interopRequireWildcard(require(\"black\"));\\n\\nfunction use1() {\\n console.log(foo1());\\n}\\nfunction use2() {\\n console.log(foo2);\\n}\\n\\n\"#\\n);\\n\\n// lazy_dep_import_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_import_named,\\n r#\"\\nimport { foo } from \"foo\";\\n\\nfunction use() {\\n console.log(foo);\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nfunction _foo() {\\n const data = require(\"foo\");\\n\\n _foo = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\nfunction use() {\\n console.log(_foo().foo);\\n}\\n\\n\"#\\n);\\n\\n// lazy_dep_reexport_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_reexport_default,\\n r#\"\\nimport foo from \"foo\";\\nexport { foo as default };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"default\", {\\n enumerable: true,\\n get: function () {\\n return _foo().default;\\n }\\n});\\n\\nfunction _foo() {\\n const data = _interopRequireDefault(require(\"foo\"));\\n\\n _foo = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\n\"#\\n);\\n\\n// interop_export_default_9\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_default_9,\\n r#\"\\nvar foo;\\nexport { foo as default };\\n\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.default = void 0;\\nvar foo;\\nexports.default = foo;\\n\\n\"#\\n);\\n\\n// misc_undefined_this_arrow_function\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n misc_undefined_this_arrow_function,\\n r#\"\\nvar foo = () => this;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar foo = () => void 0;\\n\\n\"#\\n);\\n\\n// misc_undefined_this_root_call\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n misc_undefined_this_root_call,\\n r#\"\\nthis.foo();\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\n(void 0).foo();\\n\\n\"#\\n);\\n\\n// strict_import_wildcard\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_import_wildcard,\\n r#\"\\nimport * as foo from \\'foo\\';\\n\\nfoo.bar();\\nfoo.baz();\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar foo = _interopRequireWildcard(require(\"foo\"));\\nfoo.bar();\\nfoo.baz();\\n\\n\"#\\n);\\n\\n// lazy_dep_import_default\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_dep_import_default,\\n r#\"\\nimport foo from \"foo\";\\n\\nfunction use() {\\n console.log(foo);\\n}\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nfunction _foo() {\\n const data = _interopRequireDefault(require(\"foo\"));\\n\\n _foo = function () {\\n return data;\\n };\\n\\n return data;\\n}\\n\\nfunction use() {\\n console.log(_foo().default);\\n}\\n\"#\\n);\\n\\n// lazy_local_reexport_named\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n lazy: Lazy::Bool(true),\\n ..Default::default()\\n }),\\n lazy_local_reexport_named,\\n r#\"\\nimport { named } from \"./foo\";\\nexport { named };\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\n\\nObject.defineProperty(exports, \"named\", {\\n enumerable: true,\\n get: function () {\\n return _foo.named;\\n }\\n});\\n\\nvar _foo = require(\"./foo\");\\n\"#\\n);\\n\\n// strict_export_const_destructuring_array_rest\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: true,\\n ..Default::default()\\n }),\\n strict_export_const_destructuring_array_rest,\\n r#\"\\nexport const [foo, bar, ...baz] = [];\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nexports.baz = exports.bar = exports.foo = void 0;\\nconst [foo, bar, ...baz] = [];\\nexports.foo = foo;\\nexports.bar = bar;\\nexports.baz = baz;\\n\\n\"#\\n);\\n\\n// update_expression\\n\\n// misc_reference_source_map_source\\n\\n// interop_illegal_export_esmodule\\n\\n// interop_imports_mixing\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_imports_mixing,\\n r#\"\\nimport foo, {baz as xyz} from \"foo\";\\n\\nfoo;\\nxyz;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = _interopRequireWildcard(require(\"foo\"));\\n\\n_foo.default;\\n_foo.baz;\\n\\n\"#\\n);\\n\\n// interop_overview\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_overview,\\n r#\"\\nimport \"foo\";\\nimport \"foo-bar\";\\nimport \"./directory/foo-bar\";\\nimport foo from \"foo2\";\\nimport * as foo2 from \"foo3\";\\nimport {bar} from \"foo4\";\\nimport {foo as bar2} from \"foo5\";\\n\\nvar test;\\nexport {test};\\nexport var test2 = 5;\\n\\nbar;\\nbar2;\\nfoo;\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nexports.test2 = exports.test = void 0;\\n\\nrequire(\"foo\");\\n\\nrequire(\"foo-bar\");\\n\\nrequire(\"./directory/foo-bar\");\\n\\nvar _foo2 = _interopRequireDefault(require(\"foo2\"));\\n\\nvar foo2 = _interopRequireWildcard(require(\"foo3\"));\\n\\nvar _foo4 = require(\"foo4\");\\n\\nvar _foo5 = require(\"foo5\");\\n\\nvar test;\\nexports.test = test;\\nvar test2 = 5;\\nexports.test2 = test2;\\n_foo4.bar;\\n_foo5.foo;\\n_foo2.default;\\n\\n\"#\\n);\\n\\n// interop_imports_hoisting\\n\\n// interop_export_all\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n interop_export_all,\\n r#\"\\n// The fact that this exports both a normal default, and all of the names via\\n// re-export is an edge case that is important not to miss. See\\n// https://github.com/babel/babel/issues/8306 as an example.\\nimport _default from \\'react\\';\\nexport default _default;\\nexport * from \\'react\\';\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nvar _exportNames = {};\\n\\nexports.default = void 0;\\nvar _react = _interopRequireWildcard(require(\"react\"));\\n\\n\\n// The fact that this exports both a normal default, and all of the names via\\n// re-export is an edge case that is important not to miss. See\\n// https://github.com/babel/babel/issues/8306 as an example.\\nvar _default = _react.default;\\nexports.default = _default;\\n\\nObject.keys(_react).forEach(function (key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\\n if (key in exports && exports[key] === _react[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function () {\\n return _react[key];\\n }\\n });\\n});\\n\\n\"#\\n);\\n\\n// lazy_whitelist\\n\\n// auxiliary_comment\\n\\n// source_map_exec\\ntest_exec!(\\n // We cannot inject transform at this time.\\n ignore,\\n syntax(),\\n |_| tr(Default::default()),\\n source_map_exec,\\n r#\"\\nvar tests = [\\n \\'import \"foo\";\\',\\n \\'import foo from \"foo\";\\',\\n \\'import {default as foo2} from \"foo\";\\',\\n \\'import * as foo from \"foo\";\\',\\n \\'import {bar} from \"foo\";\\',\\n \\'import {bar2, baz} from \"foo\";\\',\\n \\'import {bar as baz2} from \"foo\";\\',\\n \\'import {bar as baz3, xyz} from \"foo\";\\',\\n \\'import bar, * as bar2 from \"foo\";\\',\\n \\'import bar, {bar2, bar3 as bar4} from \"foo\";\\',\\n\\n \\'export var a;\\',\\n \\'export default function(){};\\',\\n \\'export default function f(){};\\',\\n \\'export default 42;\\',\\n \\'export {foo}; var foo;\\',\\n \\'export { foo as default }; var foo;\\',\\n \\'export * from \"foo\";\\',\\n \\'export {foo} from \"foo\";\\',\\n \\'export {default as foo} from \"foo\";\\',\\n];\\n\\ntests.forEach(function (code) {\\n var res = transform(code, {\\n sourceMap: true,\\n plugins: opts.plugins\\n });\\n\\n // Should create mapping\\n expect(res.map.mappings).not.toBe(\\'\\');\\n});\\n\\n\"#\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_396_1,\\n \"\\nfunction foo() {\\n bar;\\n function bar() {}\\n}\\n\",\\n \"\\n\\'use strict\\';\\nfunction foo() {\\n bar;\\n function bar() {\\n }\\n}\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| {\\n let mark = Mark::fresh(Mark::root());\\n\\n chain!(\\n resolver_with_mark(mark),\\n block_scoped_functions(),\\n block_scoping(),\\n common_js(mark, Default::default(), None),\\n )\\n },\\n issue_396_2,\\n \"\\nfunction foo() {\\n bar;\\n function bar() {}\\n}\\n\",\\n \"\\n\\'use strict\\';\\nfunction foo() {\\n var bar = function bar() {\\n };\\n bar;\\n}\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: false,\\n strict_mode: true,\\n no_interop: true,\\n ..Default::default()\\n }),\\n issue_456_1,\\n \"import { join as e } from \\'path\\';\\nexport const foo = function () {\\n function e(t) {}\\n return A(e, {}), e\\n}();\",\\n \"\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.foo = void 0;\\nvar _path = require(\\'path\\');\\nconst foo = function() {\\n function e(t) {\\n }\\n return A(e, {}), e;\\n}();\\nexports.foo = foo;\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: false,\\n strict_mode: true,\\n no_interop: true,\\n ..Default::default()\\n }),\\n issue_456_2,\\n \"import { join as e } from \\'path\\';\\nexport const foo = function () {\\n var e = 1;\\n return A(e, {}), e\\n}();\",\\n \"\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.foo = void 0;\\nvar _path = require(\\'path\\');\\nconst foo = function() {\\n var e = 1;\\n return A(e, {\\n }), e;\\n}();\\nexports.foo = foo;\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: false,\\n strict_mode: true,\\n no_interop: true,\\n ..Default::default()\\n }),\\n issue_605,\\n \"export * from \\'c\\';\",\\n \"\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nvar _c = require(\\'c\\');\\nObject.keys(_c).forEach(function(key) {\\n if (key === \\'default\\' || key === \\'__esModule\\') return;\\n if (key in exports && exports[key] === _c[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function() {\\n return _c[key];\\n }\\n });\\n});\\n\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: false,\\n strict_mode: true,\\n no_interop: true,\\n ..Default::default()\\n }),\\n issue_724,\\n \"import { MongoClient, Db } from \\'mongodb\\'\\n require(\\'foo\\');\",\\n \"\\'use strict\\';\\n var _mongodb = require(\\'mongodb\\');\\n require(\\'foo\\');\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n strict: false,\\n strict_mode: true,\\n ..Default::default()\\n }),\\n issue_763,\\n \"import {\\n INSTAGRAM_CHECK_PATTERN,\\n RESOURCE_FACEBOOK,\\n RESOURCE_INSTAGRAM,\\n RESOURCE_WEBSITE,\\n} from \\'../../../../consts\\'\\n\\nconst resources = [\\n {\\n value: RESOURCE_WEBSITE,\\n label: \\'Webové stránky\\',\\n },\\n {\\n value: RESOURCE_FACEBOOK,\\n label: \\'Facebook\\',\\n },\\n {\\n value: RESOURCE_INSTAGRAM,\\n label: \\'Instagram\\',\\n },\\n]\",\\n \"\\'use strict\\';\\n var _consts = require(\\'../../../../consts\\');\\n const resources = [\\n {\\n value: _consts.RESOURCE_WEBSITE,\\n label: \\'Webové stránky\\'\\n },\\n {\\n value: _consts.RESOURCE_FACEBOOK,\\n label: \\'Facebook\\'\\n },\\n {\\n value: _consts.RESOURCE_INSTAGRAM,\\n label: \\'Instagram\\'\\n }\\n ];\"\\n);\\n\\ntest!(\\n ts_syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_895,\\n \"import { queryString } from \\'./url\\'\\n\\nexport function setup(url: string, obj: any) {\\n const _queryString = queryString(obj)\\n const _url = url + \\'?\\' + _queryString\\n return _url\\n}\",\\n \"\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.setup = setup;\\nvar _url = require(\\'./url\\');\\nfunction setup(url: string, obj: any) {\\n const _queryString = (0, _url).queryString(obj);\\n const _url1 = url + \\'?\\' + _queryString;\\n return _url1;\\n}\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_962,\\n \"import root from \\'./_root.js\\';\\n import stubFalse from \\'./stubFalse.js\\';\\n \\n var freeExports = typeof exports == \\'object\\' && exports && !exports.nodeType && exports;\\n var freeModule = freeExports && typeof module == \\'object\\' && module && !module.nodeType && \\\\\\n module;\\n \\n var moduleExports = freeModule && freeModule.exports === freeExports;\\n \\n var Buffer = moduleExports ? root.Buffer : undefined;\\n \\n var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\\n \\n var isBuffer = nativeIsBuffer || stubFalse;\\n \\n export default isBuffer\",\\n r#\"\\n \"use strict\";\\n Object.defineProperty(exports, \"__esModule\", {\\n value: true\\n });\\n exports.default = void 0;\\n var _rootJs = _interopRequireDefault(require(\"./_root.js\"));\\n var _stubFalseJs = _interopRequireDefault(require(\"./stubFalse.js\"));\\n var freeExports = typeof exports == \"object\" && exports && !exports.nodeType && exports;\\n var freeModule = freeExports && typeof module == \"object\" && module && !module.nodeType && module;\\n var moduleExports = freeModule && freeModule.exports === freeExports;\\n var Buffer = moduleExports ? _rootJs.default.Buffer : undefined;\\n var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\\n var isBuffer = nativeIsBuffer || _stubFalseJs.default;\\n var _default = isBuffer;\\n exports.default = _default;\\n\"#\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_1018_1,\\n \"async function foo() {\\n await import(\\'foo\\');\\n }\",\\n \"\\n \\\\\"use strict\\\\\";\\n async function foo() {\\n await Promise.resolve().then(function() {\\n return _interopRequireWildcard(require(\\'foo\\'));\\n });\\n }\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_1043_1,\\n \"\\n export * from \\'./http\\';\\n export { Scope } from \\'./interfaces\\'\\n \",\\n r#\"\\n\"use strict\";\\nObject.defineProperty(exports, \"__esModule\", {\\n value: true\\n});\\nObject.defineProperty(exports, \"Scope\", {\\n enumerable: true,\\n get: function() {\\n return _interfaces.Scope;\\n }\\n});\\nvar _http = require(\"./http\");\\nvar _interfaces = require(\"./interfaces\");\\nObject.keys(_http).forEach(function(key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (key in exports && exports[key] === _http[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function() {\\n return _http[key];\\n }\\n });\\n});\\n \"#\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_1043_2,\\n \"\\nimport \\'reflect-metadata\\';\\n\\nexport * from \\'./http\\';\\nexport { id } from \\'./interfaces\\';\\nexport * from \\'./pipes\\';\\n\",\\n r#\"\\n \"use strict\";\\n Object.defineProperty(exports, \"__esModule\", {\\n value: true\\n });\\n Object.defineProperty(exports, \"id\", {\\n enumerable: true,\\n get: function() {\\n return _interfaces.id;\\n }\\n });\\n var _exportNames = {\\n };\\n require(\"reflect-metadata\");\\n var _http = require(\"./http\");\\n var _interfaces = require(\"./interfaces\");\\n var _pipes = require(\"./pipes\");\\n Object.keys(_http).forEach(function(key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\\n if (key in exports && exports[key] === _http[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function() {\\n return _http[key];\\n }\\n });\\n });\\n Object.keys(_pipes).forEach(function(key) {\\n if (key === \"default\" || key === \"__esModule\") return;\\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\\n if (key in exports && exports[key] === _pipes[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function() {\\n return _pipes[key];\\n }\\n });\\n });\\n \"#\\n);\\n\\ntest!(\\n syntax(),\\n |t| chain!(\\n resolver(),\\n block_scoping(),\\n classes(Some(t.comments.clone()),),\\n destructuring(Default::default()),\\n common_js(Mark::fresh(Mark::root()), Default::default(), None)\\n ),\\n issue_578_2,\\n \"\\nimport { myFunction } from \\'./dep.js\\'\\n\\nclass SomeClass {\\n constructor(properties) {\\n this.props = properties;\\n }\\n call () {\\n const {myFunction} = this.props\\n if (myFunction) {\\n myFunction()\\n } else {\\n console.log(\\'DID NOT WORK!\\')\\n }\\n }\\n}\\n\\nlet instance = new SomeClass({\\n myFunction: () => {\\n console.log(\\'CORRECT FUNCTION CALLED\\')\\n }\\n});\\n\\ninstance.call()\",\\n \"\\'use strict\\';\\nvar _depJs = require(\\'./dep.js\\');\\nlet SomeClass = function() {\\n \\'use strict\\';\\n function SomeClass(properties) {\\n _classCallCheck(this, SomeClass);\\n this.props = properties;\\n }\\n _createClass(SomeClass, [{\\n key: \\'call\\',\\n value: function call() {\\n var _props = this.props, myFunction = _props.myFunction;\\n if (myFunction) {\\n myFunction();\\n } else {\\n console.log(\\'DID NOT WORK!\\');\\n }\\n }\\n }]);\\n return SomeClass;\\n}();\\nvar instance = new SomeClass({\\n myFunction: ()=>{\\n console.log(\\'CORRECT FUNCTION CALLED\\');\\n }\\n});\\ninstance.call();\",\\n ok_if_code_eq\\n);\\n\\n// for_of_as_array_for_of_import_commonjs\\ntest!(\\n syntax(),\\n |_| chain!(\\n for_of(for_of::Config { assume_array: true }),\\n common_js(Mark::fresh(Mark::root()), Default::default(), None)\\n ),\\n for_of_as_array_for_of_import_commonjs,\\n r#\"\\nimport { array } from \"foo\";\\n\\nfor (const elm of array) {\\nconsole.log(elm);\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _foo = require(\"foo\");\\n\\nfor(let _i = 0; _i < _foo.array.length; _i++){\\nconst elm = _foo.array[_i];\\nconsole.log(elm);\\n}\\n\\n\"#\\n);\\n\\n// regression_t7178\\ntest!(\\n syntax(),\\n |_| chain!(\\n resolver(),\\n object_rest_spread(),\\n destructuring(destructuring::Config { loose: false }),\\n common_js(Mark::fresh(Mark::root()), Default::default(), None),\\n ),\\n regression_t7178,\\n r#\"\\nimport props from \"props\";\\n\\nconsole.log(props);\\n\\n(function(){\\nconst { ...props } = this.props;\\n\\nconsole.log(props);\\n})();\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _props = _interopRequireDefault(require(\"props\"));\\n\\nconsole.log(_props.default);\\n\\n(function () {\\nconst props = _extends({}, this.props);\\nconsole.log(props);\\n})();\\n\\n\"#\\n);\\n\\n// regression_4209\\ntest!(\\n syntax(),\\n |t| chain!(\\n classes(Some(t.comments.clone()),),\\n parameters(),\\n destructuring(Default::default()),\\n block_scoping(),\\n common_js(Mark::fresh(Mark::root()), Default::default(), None),\\n ),\\n regression_4209,\\n r#\"\\nimport { copy } from \\'./copyPaste\\';\\n\\nclass Thing {\\nhandleCopySomething() {\\n copy();\\n}\\n\\ncompletelyUnrelated(copy = 123) {\\n}\\n}\\n\\n\"#,\\n r#\"\\n\"use strict\";\\n\\nvar _copyPaste = require(\"./copyPaste\");\\n\\nvar Thing =\\n/*#__PURE__*/\\nfunction () {\\n\\'use strict\\';\\nfunction Thing() {\\n _classCallCheck(this, Thing);\\n}\\n\\n_createClass(Thing, [{\\n key: \"handleCopySomething\",\\n value: function handleCopySomething() {\\n (0, _copyPaste).copy();\\n }\\n}, {\\n key: \"completelyUnrelated\",\\n value: function completelyUnrelated(param) {\\n var copy = param === void 0 ? 123 : param;\\n }\\n}]);\\n\\nreturn Thing;\\n}();\\n\\n\"#\\n);\\n\\n// regression_6647\\ntest!(\\n syntax(),\\n |_| chain!(\\n spread(spread::Config {\\n ..Default::default()\\n }),\\n common_js(Mark::fresh(Mark::root()), Default::default(), None)\\n ),\\n regression_6647,\\n r#\"\\nimport a from \\'a\\';\\na.preview(...c);\\n\\n\"#,\\n r#\"\\n\\'use strict\\';\\nvar _a = _interopRequireDefault(require(\\'a\\'));\\nvar _a1;\\n(_a1 = _a.default).preview.apply(_a1, _toConsumableArray(c));\\n\"#\\n);\\n\\n// regression_6733\\ntest!(\\n syntax(),\\n |_| chain!(\\n resolver(),\\n regenerator(Mark::fresh(Mark::root())),\\n common_js(Mark::fresh(Mark::root()), Default::default(), None)\\n ),\\n regression_6733,\\n r#\"\\nexport default function * () {\\nvar x = yield 5;\\nreturn 5;\\n}\\n\\n\"#,\\n r#\"\\n \"use strict\";\\n Object.defineProperty(exports, \"__esModule\", {\\n value: true\\n });\\n exports.default = _callee;\\n var _regeneratorRuntime = _interopRequireDefault(require(\\'regenerator-runtime\\'));\\n function _callee() {\\n var x;\\n return _regeneratorRuntime.default.wrap(function _callee$(_ctx) {\\n while(1)switch(_ctx.prev = _ctx.next){\\n case 0:\\n _ctx.next = 2;\\n return 5;\\n case 2:\\n x = _ctx.sent;\\n return _ctx.abrupt(\"return\", 5);\\n case 4:\\n case \"end\":\\n return _ctx.stop();\\n }\\n }, _callee);\\n }\\n\"#\\n);\\n\\n// test interop between cjs module and regenerator\\ntest!(\\n syntax(),\\n |_| {\\n let mark = Mark::fresh(Mark::root());\\n\\n chain!(regenerator(mark), common_js(mark, Default::default(), None),)\\n },\\n issue_831_2,\\n \"export function* myGenerator() {\\n yield* [1,2,3];\\n }\",\\n \"\\'use strict\\';\\nObject.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n});\\nexports.myGenerator = myGenerator;\\nvar _regeneratorRuntime = _interopRequireDefault(require(\\'regenerator-runtime\\'));\\nvar _marked = _regeneratorRuntime.default.mark(myGenerator);\\nfunction myGenerator() {\\n return _regeneratorRuntime.default.wrap(function myGenerator$(_ctx) {\\n while(1)switch(_ctx.prev = _ctx.next){\\n case 0:\\n return _ctx.delegateYield([\\n 1,\\n 2,\\n 3\\n ], \\\\\"t0\\\\\", 1);\\n case 1:\\n case \\'end\\':\\n return _ctx.stop();\\n }\\n }, _marked);\\n}\"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_1213,\\n \"\\n import foo from \\'foo\\';\\n\\n class OK {\\n constructor() {\\n console.log(foo);\\n }\\n }\\n \\n export default class NotOK {\\n constructor() {\\n console.log(foo);\\n }\\n }\\n \",\\n \"\\n \\'use strict\\';\\n Object.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n });\\n exports.default = void 0;\\n \\n var _foo = _interopRequireDefault(require(\\'foo\\'));\\n \\n class OK {\\n constructor() {\\n console.log(_foo.default);\\n }\\n }\\n class NotOK {\\n constructor() {\\n console.log(_foo.default);\\n }\\n }\\n exports.default = NotOK;\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n ..Default::default()\\n }),\\n issue_1423_1,\\n \"\\n \\'use strict\\';\\n import { arrayUtilities } from \\'necessary\\';\\n\\n const { second } = arrayUtilities;\\n\\n const elements = [1, 2, 3],\\n secondElement = second(elements);\\n\\n console.log(secondElement)\\n \",\\n \"\\n \\'use strict\\';\\n var _necessary = require(\\'necessary\\');\\n const { second } = _necessary.arrayUtilities;\\n const elements = [\\n 1,\\n 2,\\n 3\\n ], secondElement = second(elements);\\n console.log(secondElement);\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n no_interop: false,\\n strict: true,\\n strict_mode: true,\\n lazy: Lazy::Bool(false)\\n }),\\n issue_1480_1,\\n \"\\n const { default: ora } = await import(\\'ora\\')\\n \",\\n \"\\n \\'use strict\\';\\n const { default: ora } = await Promise.resolve().then(function() {\\n return _interopRequireWildcard(require(\\'ora\\'));\\n });\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Config {\\n no_interop: false,\\n strict: true,\\n strict_mode: true,\\n lazy: Lazy::Bool(false)\\n }),\\n issue_1480_2,\\n \"\\n import * as ora from \\'ora\\'\\n\",\\n \"\\n \\'use strict\\';\\n var ora = _interopRequireWildcard(require(\\'ora\\'));\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1568_1,\\n \"\\n export default function get(key) {\\n console.log(key);\\n }\\n \",\\n \"\\n \\'use strict\\';\\n Object.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n });\\n\\n exports.default = get;\\n\\n function get(key) {\\n console.log(key);\\n }\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1568_2,\\n \"\\n export function get(key) {\\n console.log(key);\\n }\\n\\n export default a;\\n \",\\n \"\\n \\'use strict\\';\\n Object.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n });\\n exports.get = get;\\n exports.default = void 0;\\n \\n function get(key) {\\n console.log(key);\\n }\\n \\n var _default = a;\\n exports.default = _default;\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1588_1,\\n \"\\n import { Component, default as React } from \\'react\\';\\n\\n class X extends Component {\\n }\\n\\n React.render();\\n \",\\n \"\\n \\'use strict\\';\\n var _react = _interopRequireWildcard(require(\\'react\\'));\\n class X extends _react.Component {\\n }\\n _react.default.render();\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1614_1,\\n \"\\n (async () => {\\n const example = await import(\\'./example\\');\\n console.log(example.foo)\\n })()\\n \",\\n \"\\n \\'use strict\\';\\n (async ()=>{\\n const example = await Promise.resolve().then(function() {\\n return _interopRequireWildcard(require(\\'./example\\'));\\n });\\n console.log(example.foo);\\n })();\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1780_1,\\n \"\\n export const BIZ = \\'biz\\';\\n export * from \\'./File1\\';\\n export * from \\'./File2\\';\\n \",\\n \"\\n \\'use strict\\';\\n Object.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n });\\n var _exportNames = {\\n BIZ: true\\n };\\n exports.BIZ = void 0;\\n var _file1 = require(\\'./File1\\');\\n var _file2 = require(\\'./File2\\');\\n const BIZ = \\'biz\\';\\n exports.BIZ = BIZ;\\n Object.keys(_file1).forEach(function(key) {\\n if (key === \\'default\\' || key === \\'__esModule\\') return;\\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\\n if (key in exports && exports[key] === _file1[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function() {\\n return _file1[key];\\n }\\n });\\n });\\n Object.keys(_file2).forEach(function(key) {\\n if (key === \\'default\\' || key === \\'__esModule\\') return;\\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\\n if (key in exports && exports[key] === _file2[key]) return;\\n Object.defineProperty(exports, key, {\\n enumerable: true,\\n get: function() {\\n return _file2[key];\\n }\\n });\\n });\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1757_1,\\n \"\\n import \\'testlibrary\\';\\n import { aFunc } from \\'testlibrary\\';\\n\\n console.log(\\'aFunc: \\', aFunc(1,2));\\n \",\\n \"\\n \\'use strict\\';\\n var _testlibrary = require(\\'testlibrary\\');\\n console.log(\\'aFunc: \\', (0, _testlibrary).aFunc(1, 2));\\n \"\\n);\\ntest!(\\n syntax(),\\n |_| {\\n let scope = Rc::new(RefCell::new(Scope::default()));\\n chain!(\\n import_analyzer(Rc::clone(&scope)),\\n inject_helpers(),\\n common_js(Mark::fresh(Mark::root()), Default::default(), Some(scope)),\\n hygiene(),\\n fixer(None)\\n )\\n },\\n issue_1786_1,\\n \"\\n import Foo from \\'foo\\';\\n export {Foo} from \\'foo\\';\\n \",\\n \"\\n \\'use strict\\';\\n Object.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n });\\n Object.defineProperty(exports, \\'Foo\\', {\\n enumerable: true,\\n get: function() {\\n return _foo.Foo;\\n }\\n });\\n var _foo = _interopRequireWildcard(require(\\'foo\\'));\\n function _interopRequireWildcard(obj) {\\n if (obj && obj.__esModule) {\\n return obj;\\n } else {\\n var newObj = {};\\n if (obj != null) {\\n for(var key in obj) {\\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\\n var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? \\\\\\n Object.getOwnPropertyDescriptor(obj, key) : {};\\n if (desc.get || desc.set) {\\n Object.defineProperty(newObj, key, desc);\\n } else {\\n newObj[key] = obj[key];\\n }\\n }\\n }\\n }\\n newObj.default = obj;\\n return newObj;\\n }\\n }\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1787_1,\\n \"\\n import bar from \\'./bar/foo\\';\\n import baz from \\'./baz/foo\\';\\n const a = [baz, bar];\\n \",\\n \"\\n \\'use strict\\';\\n var _foo = _interopRequireDefault(require(\\'./bar/foo\\'));\\n var _foo1 = _interopRequireDefault(require(\\'./baz/foo\\'));\\n const a = [_foo1.default, _foo.default];\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1799_1,\\n \"\\n export default function Foo() {\\n return 500;\\n }\\n \",\\n \"\\n \\'use strict\\';\\n Object.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n });\\n exports.default = Foo;\\n function Foo() {\\n return 500;\\n }\\n \"\\n);\\n\\ntest!(\\n syntax(),\\n |_| tr(Default::default()),\\n issue_1799_2,\\n \"\\n export default function () {\\n return 500;\\n }\\n \",\\n \"\\n \\'use strict\\';\\n Object.defineProperty(exports, \\'__esModule\\', {\\n value: true\\n });\\n exports.default = _default;\\n function _default() {\\n return 500;\\n }\\n \"\\n);\\n\\n#[testing::fixture(\"tests/fixture/commonjs/**/input.js\")]\\nfn fixture(input: PathBuf) {\\n let dir = input.parent().unwrap().to_path_buf();\\n\\n let output = dir.join(\"output.js\");\\n\\n test_fixture(\\n Default::default(),\\n &|_| tr(Default::default()),\\n &input,\\n &output,\\n );\\n}\\n',\n", + " 'content_id': '62498088f45586b7d32e49d8213c63aa63fe6892',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 102,\n", + " 'path': '/ecmascript/transforms/module/tests/common_js.rs',\n", + " 'size': 83569,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3678446062440307,\n", + " 'avg_line_length': 38.250730282375855,\n", + " 'blob_id': 'fc7d036b9ee42a68e63d6a69adbac82205000645',\n", + " 'content': 'use rustc_hash::{FxHashMap, FxHashSet};\\nuse serde::{Deserialize, Serialize};\\nuse std::{borrow::Borrow, mem::take};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{\\n util::{move_map::MoveMap, take::Take},\\n Span, Spanned, SyntaxContext, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{\\n constructor::inject_after_super, default_constructor, ident::IdentLike, member_expr, prepend,\\n private_ident, quote_ident, replace_ident, var::VarCollector, ExprFactory, Id, ModuleItemLike,\\n StmtLike,\\n};\\nuse swc_ecma_visit::{as_folder, Fold, Node, Visit, VisitMut, VisitMutWith, VisitWith};\\n\\n/// Value does not contain TsLit::Bool\\ntype EnumValues = FxHashMap;\\n\\n#[derive(Debug, Serialize, Deserialize)]\\n#[non_exhaustive]\\npub enum ImportsNotUsedAsValues {\\n #[serde(rename = \"remove\")]\\n Remove,\\n #[serde(rename = \"preserve\")]\\n Preserve,\\n}\\n\\n#[deprecated = \"ImportNotUsedAsValues is renamed to ImportsNotUsedAsValues\"]\\npub type ImportNotUsedAsValues = ImportsNotUsedAsValues;\\n\\n/// This value defaults to `Remove`\\nimpl Default for ImportsNotUsedAsValues {\\n fn default() -> Self {\\n Self::Remove\\n }\\n}\\n\\n#[derive(Debug, Default, Serialize, Deserialize)]\\npub struct Config {\\n #[serde(default)]\\n pub import_not_used_as_values: ImportsNotUsedAsValues,\\n /// Align the semantics of TS class fields with TC39 class fields. Defaults\\n /// to `false`.\\n ///\\n /// See https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#the-usedefineforclassfields-flag-and-the-declare-property-modifier.\\n ///\\n /// When running `tsc` with configuration `\"target\": \"ESNext\",\\n /// \"useDefineForClassFields\": true`, TS class fields are preserved as JS\\n /// class fields. We target ESNext, so this our behavior with\\n /// `use_define_for_class_fields: true`.\\n ///\\n /// When running `tsc` with configuration `\"target\": \"\",\\n /// \"useDefineForClassFields\": true`, TS class fields are transformed to\\n /// `Object.defineProperty()` statements. You must additionally apply the\\n /// `swc_ecmascript::transforms::compat::es2020::class_properties()` pass to\\n /// get this backward-compatible output.\\n #[serde(default)]\\n pub use_define_for_class_fields: bool,\\n\\n /// Don\\'t create `export {}`.\\n /// By default, strip creates `export {}` for modules to preserve module\\n /// context.\\n ///\\n /// https://github.com/swc-project/swc/issues/1698\\n #[serde(default)]\\n pub no_empty_export: bool,\\n}\\n\\npub fn strip_with_config(config: Config) -> impl Fold + VisitMut {\\n as_folder(Strip {\\n config,\\n ..Default::default()\\n })\\n}\\n\\n/// Strips type annotations out.\\npub fn strip() -> impl Fold {\\n strip_with_config(Default::default())\\n}\\n\\n#[derive(Default)]\\nstruct Strip {\\n config: Config,\\n non_top_level: bool,\\n scope: Scope,\\n\\n is_side_effect_import: bool,\\n is_type_only_export: bool,\\n uninitialized_vars: Vec,\\n\\n /// Names of top-level declarations.\\n /// This is used to prevent emittnig a variable with same name multiple\\n /// name.\\n ///\\n /// If an identifier is in this list, thre [VisitMut] impl should not add a\\n /// varaible with it.\\n ///\\n /// This field is filled by [Visit] impl and [VisitMut] impl.\\n decl_names: FxHashSet,\\n in_var_pat: bool,\\n}\\n\\nimpl Strip {\\n /// Creates an uninitialized variable if `name` is not in scope.\\n fn create_uninit_var(&mut self, span: Span, name: Id) -> Option {\\n if !self.decl_names.insert(name.clone()) {\\n return None;\\n }\\n\\n Some(VarDeclarator {\\n span,\\n name: Pat::Ident(BindingIdent {\\n id: Ident::new(name.0, DUMMY_SP.with_ctxt(name.1)),\\n type_ann: None,\\n }),\\n init: None,\\n definite: false,\\n })\\n }\\n}\\n\\n#[derive(Default)]\\nstruct Scope {\\n decls: FxHashMap,\\n referenced_idents: FxHashMap,\\n}\\n\\n#[derive(Debug, Default)]\\nstruct DeclInfo {\\n /// interface / type alias\\n has_type: bool,\\n /// Var, Fn, Class\\n has_concrete: bool,\\n}\\n\\nimpl Strip {\\n fn store(&mut self, sym: JsWord, ctxt: SyntaxContext, concrete: bool) {\\n let entry = self.scope.decls.entry((sym, ctxt)).or_default();\\n\\n if concrete {\\n entry.has_concrete = true\\n } else {\\n entry.has_type = true;\\n }\\n }\\n\\n fn handle_decl(&mut self, decl: &Decl) {\\n // We don\\'t care about stuffs which cannot be exported\\n if self.non_top_level {\\n return;\\n }\\n\\n match *decl {\\n Decl::Class(ClassDecl { ref ident, .. }) | Decl::Fn(FnDecl { ref ident, .. }) => {\\n self.store(ident.sym.clone(), ident.span.ctxt, true);\\n }\\n\\n Decl::Var(ref var) => {\\n let mut names = vec![];\\n var.decls.visit_with(\\n &Invalid { span: DUMMY_SP } as _,\\n &mut VarCollector { to: &mut names },\\n );\\n\\n for name in names {\\n self.store(name.0.clone(), name.1, true);\\n }\\n }\\n\\n Decl::TsEnum(TsEnumDecl { ref id, .. }) => {\\n // Currently swc cannot remove constant enums\\n self.store(id.sym.clone(), id.span.ctxt, true);\\n self.store(id.sym.clone(), id.span.ctxt, false);\\n }\\n\\n Decl::TsInterface(TsInterfaceDecl { ref id, .. })\\n | Decl::TsModule(TsModuleDecl {\\n id: TsModuleName::Ident(ref id),\\n ..\\n })\\n | Decl::TsTypeAlias(TsTypeAliasDecl { ref id, .. }) => {\\n self.store(id.sym.clone(), id.span.ctxt, false)\\n }\\n\\n Decl::TsModule(TsModuleDecl {\\n id:\\n TsModuleName::Str(Str {\\n ref value, span, ..\\n }),\\n ..\\n }) => self.store(value.clone(), span.ctxt, false),\\n }\\n }\\n}\\n\\nimpl Strip {\\n fn fold_class_as_decl(\\n &mut self,\\n ident: Ident,\\n orig_ident: Option,\\n mut class: Class,\\n ) -> (Decl, Vec>) {\\n class.is_abstract = false;\\n class.type_params = None;\\n class.super_type_params = None;\\n class.implements = Default::default();\\n\\n class.body.retain(|c| match c {\\n ClassMember::Constructor(Constructor { body: None, .. }) => false,\\n _ => true,\\n });\\n\\n let mut extra_exprs = vec![];\\n if self.config.use_define_for_class_fields {\\n let mut param_class_fields = vec![];\\n for member in &class.body {\\n match member {\\n ClassMember::Constructor(constructor) => {\\n for param in &constructor.params {\\n match param {\\n ParamOrTsParamProp::TsParamProp(param_prop) => {\\n let ident = match ¶m_prop.param {\\n TsParamPropParam::Ident(ident) => ident.id.clone(),\\n TsParamPropParam::Assign(pat) => {\\n pat.clone().left.ident().unwrap().id\\n }\\n };\\n let param_class_field = ClassMember::ClassProp(ClassProp {\\n span: class.span,\\n key: Box::new(Expr::Ident(ident)),\\n value: None,\\n type_ann: None,\\n is_static: false,\\n decorators: param_prop.decorators.clone(),\\n computed: false,\\n accessibility: param_prop.accessibility.clone(),\\n is_abstract: false,\\n is_optional: false,\\n is_override: param_prop.is_override,\\n readonly: param_prop.readonly,\\n declare: false,\\n definite: false,\\n });\\n param_class_fields.push(param_class_field);\\n }\\n _ => {}\\n }\\n }\\n break;\\n }\\n _ => {}\\n }\\n }\\n if !param_class_fields.is_empty() {\\n param_class_fields.append(&mut class.body.take());\\n class.body = param_class_fields;\\n }\\n } else {\\n for m in class.body.iter_mut() {\\n match m {\\n ClassMember::ClassProp(m) => {\\n if let Some(orig_ident) = &orig_ident {\\n replace_ident(&mut m.value, orig_ident.to_id(), &ident)\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n let mut key_computations = vec![];\\n let mut assign_exprs = vec![];\\n let mut new_body = vec![];\\n for member in take(&mut class.body) {\\n match member {\\n ClassMember::ClassProp(mut class_field)\\n if !class_field.is_static && class_field.decorators.is_empty() =>\\n {\\n if let Some(value) = class_field.value.take() {\\n if class_field.computed {\\n let ident = private_ident!(\"_key\");\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(ident.clone().into()),\\n init: None,\\n definite: false,\\n });\\n let assign_lhs =\\n PatOrExpr::Expr(Box::new(Expr::Ident(ident.clone())));\\n let assign_expr = Box::new(Expr::Assign(AssignExpr {\\n span: class_field.span,\\n op: op!(\"=\"),\\n left: assign_lhs,\\n right: class_field.key.take(),\\n }));\\n key_computations.push(assign_expr);\\n class_field.key = Box::new(Expr::Ident(ident));\\n }\\n let computed = class_field.computed\\n || !matches!(class_field.key.borrow(), Expr::Ident(_));\\n let assign_lhs = PatOrExpr::Expr(Box::new(Expr::Member(MemberExpr {\\n span: class_field.span,\\n obj: ExprOrSuper::Expr(Box::new(Expr::This(ThisExpr {\\n span: class.span,\\n }))),\\n prop: class_field.key,\\n computed,\\n })));\\n let assign_expr = Box::new(Expr::Assign(AssignExpr {\\n span: class_field.span,\\n op: op!(\"=\"),\\n left: assign_lhs,\\n right: value,\\n }));\\n assign_exprs.push(assign_expr);\\n }\\n }\\n ClassMember::ClassProp(mut class_field)\\n if class_field.is_static && class_field.decorators.is_empty() =>\\n {\\n if let Some(value) = class_field.value.take() {\\n if class_field.computed {\\n let ident = private_ident!(\"_key\");\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(ident.clone().into()),\\n init: None,\\n definite: false,\\n });\\n let assign_lhs =\\n PatOrExpr::Expr(Box::new(Expr::Ident(ident.clone())));\\n let assign_expr = Box::new(Expr::Assign(AssignExpr {\\n span: class_field.span,\\n op: op!(\"=\"),\\n left: assign_lhs,\\n right: class_field.key.take(),\\n }));\\n key_computations.push(assign_expr);\\n class_field.key = Box::new(Expr::Ident(ident));\\n }\\n let computed = class_field.computed\\n || !matches!(class_field.key.borrow(), Expr::Ident(_));\\n let assign_lhs = PatOrExpr::Expr(Box::new(Expr::Member(MemberExpr {\\n span: DUMMY_SP,\\n obj: ident.clone().as_obj(),\\n prop: class_field.key,\\n computed,\\n })));\\n extra_exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: assign_lhs,\\n right: value,\\n })));\\n }\\n }\\n ClassMember::Method(mut method) => {\\n if !key_computations.is_empty() {\\n match &mut method.key {\\n PropName::Computed(name) => {\\n // If a computed method name is encountered, dump the other key\\n // assignments before it in a sequence expression. Note how this\\n // always preserves the order of key computations. This\\n // behaviour is taken from TSC output.\\n key_computations.push(name.expr.take());\\n name.expr = Box::new(Expr::Seq(SeqExpr {\\n span: name.span,\\n exprs: take(&mut key_computations),\\n }));\\n }\\n _ => {}\\n }\\n }\\n new_body.push(ClassMember::Method(method));\\n }\\n _ => {\\n new_body.push(member);\\n }\\n }\\n }\\n if !assign_exprs.is_empty() {\\n for member in &mut new_body {\\n match member {\\n ClassMember::Constructor(constructor) => {\\n inject_after_super(constructor, take(&mut assign_exprs));\\n break;\\n }\\n _ => {}\\n }\\n }\\n if !assign_exprs.is_empty() {\\n let mut constructor = default_constructor(class.super_class.is_some());\\n inject_after_super(&mut constructor, assign_exprs);\\n new_body.push(ClassMember::Constructor(constructor));\\n }\\n }\\n class.body = new_body;\\n key_computations.append(&mut extra_exprs);\\n extra_exprs = key_computations;\\n }\\n\\n class.decorators.visit_mut_with(self);\\n class.body.visit_mut_with(self);\\n class.super_class.visit_mut_with(self);\\n extra_exprs.visit_mut_with(self);\\n (\\n Decl::Class(ClassDecl {\\n ident,\\n declare: false,\\n class,\\n }),\\n extra_exprs,\\n )\\n }\\n\\n fn visit_mut_stmt_like(&mut self, stmts: &mut Vec)\\n where\\n T: StmtLike + ModuleItemLike + VisitMutWith,\\n {\\n for stmt in take(stmts) {\\n match T::try_into_stmt(stmt) {\\n Ok(stmt) => match stmt {\\n Stmt::Decl(Decl::Class(ClassDecl {\\n ident,\\n declare: false,\\n class,\\n })) => {\\n let orig_ident = ident.clone();\\n let (decl, extra_exprs) =\\n self.fold_class_as_decl(ident, Some(orig_ident), class);\\n stmts.push(T::from_stmt(Stmt::Decl(decl)));\\n stmts.extend(extra_exprs.into_iter().map(|e| T::from_stmt(e.into_stmt())));\\n }\\n _ => stmts.push(T::from_stmt(stmt)),\\n },\\n Err(node) => match node.try_into_module_decl() {\\n Ok(decl) => match decl {\\n ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n span,\\n decl: DefaultDecl::Class(ClassExpr { ident, class }),\\n ..\\n }) => {\\n let orig_ident = ident.clone();\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_class\"));\\n let (decl, extra_exprs) =\\n self.fold_class_as_decl(ident.clone(), orig_ident, class);\\n stmts.push(T::from_stmt(Stmt::Decl(decl)));\\n stmts.extend(\\n extra_exprs.into_iter().map(|e| T::from_stmt(e.into_stmt())),\\n );\\n stmts.push(\\n match T::try_from_module_decl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span,\\n specifiers: vec![ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: ident,\\n exported: Some(Ident::new(\\n js_word!(\"default\"),\\n DUMMY_SP,\\n )),\\n is_type_only: false,\\n }\\n .into()],\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )) {\\n Ok(t) => t,\\n Err(..) => unreachable!(),\\n },\\n );\\n }\\n ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl:\\n Decl::Class(ClassDecl {\\n ident,\\n declare: false,\\n class,\\n }),\\n ..\\n }) => {\\n let orig_ident = ident.clone();\\n let (decl, extra_exprs) =\\n self.fold_class_as_decl(ident, Some(orig_ident), class);\\n stmts.push(\\n match T::try_from_module_decl(ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl,\\n })) {\\n Ok(t) => t,\\n Err(..) => unreachable!(),\\n },\\n );\\n stmts.extend(\\n extra_exprs.into_iter().map(|e| T::from_stmt(e.into_stmt())),\\n );\\n }\\n _ => stmts.push(match T::try_from_module_decl(decl) {\\n Ok(t) => t,\\n Err(..) => unreachable!(),\\n }),\\n },\\n Err(_) => unreachable!(),\\n },\\n }\\n }\\n }\\n\\n /// Returns [Some] if the method should be called again.\\n fn handle_expr<\\'a>(&mut self, n: &\\'a mut Expr) -> Vec<&\\'a mut Expr> {\\n if n.is_class() {\\n let ClassExpr {\\n ident: old_ident,\\n class,\\n } = n.take().class().unwrap();\\n let ident = private_ident!(\"_class\");\\n let (decl, extra_exprs) =\\n self.fold_class_as_decl(ident.clone(), old_ident.clone(), class);\\n let class_expr = Box::new(Expr::Class(ClassExpr {\\n ident: old_ident,\\n class: decl.class().unwrap().class,\\n }));\\n if extra_exprs.is_empty() {\\n *n = *class_expr;\\n } else {\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(ident.clone().into()),\\n init: None,\\n definite: false,\\n });\\n let assign_lhs = PatOrExpr::Pat(Box::new(Pat::Ident(BindingIdent {\\n id: ident.clone(),\\n type_ann: None,\\n })));\\n let assign_expr = Box::new(Expr::Assign(AssignExpr {\\n span: n.span(),\\n op: op!(\"=\"),\\n left: assign_lhs,\\n right: class_expr,\\n }));\\n let mut exprs = vec![];\\n exprs.push(assign_expr);\\n exprs.extend(extra_exprs);\\n exprs.push(Box::new(Expr::Ident(ident)));\\n *n = Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs,\\n });\\n }\\n return vec![];\\n }\\n match n {\\n Expr::Bin(BinExpr { left, right, .. }) => return vec![&mut **left, &mut **right],\\n\\n // Remove types\\n Expr::TsAs(TsAsExpr { expr, .. })\\n | Expr::TsNonNull(TsNonNullExpr { expr, .. })\\n | Expr::TsTypeAssertion(TsTypeAssertion { expr, .. })\\n | Expr::TsConstAssertion(TsConstAssertion { expr, .. }) => {\\n expr.visit_mut_with(self);\\n let expr = *expr.take();\\n *n = expr;\\n }\\n\\n Expr::Member(MemberExpr {\\n obj,\\n prop,\\n computed,\\n ..\\n }) => {\\n obj.visit_mut_with(self);\\n\\n if *computed {\\n prop.visit_mut_with(self);\\n } else {\\n match &mut **prop {\\n Expr::Ident(i) => {\\n i.optional = false;\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n _ => {\\n n.visit_mut_children_with(self);\\n }\\n }\\n\\n vec![]\\n }\\n\\n fn handle_enum(&mut self, e: TsEnumDecl, stmts: &mut Vec)\\n where\\n T: StmtLike,\\n {\\n /// Called only for enums.\\n ///\\n /// If both of the default value and the initialization is None, this\\n /// method returns [Err].\\n fn compute(\\n e: &TsEnumDecl,\\n span: Span,\\n values: &mut EnumValues,\\n default: Option,\\n init: Option<&Expr>,\\n ) -> Result {\\n fn compute_bin(\\n e: &TsEnumDecl,\\n span: Span,\\n values: &mut EnumValues,\\n expr: &BinExpr,\\n ) -> Result {\\n let l = compute(e, span, values, None, Some(&expr.left))?;\\n let r = compute(e, span, values, None, Some(&expr.right))?;\\n\\n Ok(match (l, r) {\\n (\\n TsLit::Number(Number { value: l, .. }),\\n TsLit::Number(Number { value: r, .. }),\\n ) => {\\n TsLit::Number(Number {\\n span,\\n value: match expr.op {\\n op!(bin, \"+\") => l + r,\\n op!(bin, \"-\") => l - r,\\n op!(\"*\") => l * r,\\n op!(\"/\") => l / r,\\n\\n // TODO\\n op!(\"&\") => ((l.round() as i64) & (r.round() as i64)) as _,\\n op!(\"|\") => ((l.round() as i64) | (r.round() as i64)) as _,\\n op!(\"^\") => ((l.round() as i64) ^ (r.round() as i64)) as _,\\n\\n op!(\"<<\") => ((l.round() as i64) << (r.round() as i64)) as _,\\n op!(\">>\") => ((l.round() as i64) >> (r.round() as i64)) as _,\\n // TODO: Verify this\\n op!(\">>>\") => ((l.round() as u64) >> (r.round() as u64)) as _,\\n _ => Err(())?,\\n },\\n })\\n }\\n (TsLit::Str(l), TsLit::Str(r)) if expr.op == op!(bin, \"+\") => TsLit::Str(Str {\\n span,\\n value: format!(\"{}{}\", l.value, r.value).into(),\\n has_escape: l.has_escape || r.has_escape,\\n kind: Default::default(),\\n }),\\n (TsLit::Number(l), TsLit::Str(r)) if expr.op == op!(bin, \"+\") => {\\n TsLit::Str(Str {\\n span,\\n value: format!(\"{}{}\", l.value, r.value).into(),\\n has_escape: r.has_escape,\\n kind: Default::default(),\\n })\\n }\\n (TsLit::Str(l), TsLit::Number(r)) if expr.op == op!(bin, \"+\") => {\\n TsLit::Str(Str {\\n span,\\n value: format!(\"{}{}\", l.value, r.value).into(),\\n has_escape: l.has_escape,\\n kind: Default::default(),\\n })\\n }\\n _ => Err(())?,\\n })\\n }\\n\\n if let Some(expr) = init {\\n match expr {\\n Expr::Lit(Lit::Str(s)) => return Ok(TsLit::Str(s.clone())),\\n Expr::Lit(Lit::Num(s)) => return Ok(TsLit::Number(*s)),\\n Expr::Bin(ref bin) => return compute_bin(e, span, values, &bin),\\n Expr::Paren(ref paren) => {\\n return compute(e, span, values, default, Some(&paren.expr))\\n }\\n\\n Expr::Ident(ref id) => {\\n if let Some(v) = values.get(&id.clone().into_id()) {\\n return Ok(v.clone());\\n }\\n //\\n for m in e.members.iter() {\\n match m.id {\\n TsEnumMemberId::Str(Str { value: ref sym, .. })\\n | TsEnumMemberId::Ident(Ident { ref sym, .. }) => {\\n if *sym == id.sym {\\n return compute(\\n e,\\n span,\\n values,\\n None,\\n m.init.as_ref().map(|v| &**v),\\n );\\n }\\n }\\n }\\n }\\n return Err(());\\n }\\n Expr::Unary(ref expr) => {\\n let v = compute(e, span, values, None, Some(&expr.arg))?;\\n match v {\\n TsLit::BigInt(BigInt { .. }) => {}\\n TsLit::Number(Number { value: v, .. }) => {\\n return Ok(TsLit::Number(Number {\\n span,\\n value: match expr.op {\\n op!(unary, \"+\") => v,\\n op!(unary, \"-\") => -v,\\n op!(\"!\") => {\\n if v == 0.0f64 {\\n 0.0\\n } else {\\n 1.0\\n }\\n }\\n op!(\"~\") => (!(v as i32)) as f64,\\n _ => Err(())?,\\n },\\n }))\\n }\\n TsLit::Str(_) => {}\\n TsLit::Bool(_) => {}\\n TsLit::Tpl(_) => {}\\n }\\n }\\n\\n Expr::Tpl(ref t) if t.exprs.is_empty() => {\\n if let Some(v) = &t.quasis[0].cooked {\\n return Ok(v.clone().into());\\n }\\n }\\n\\n _ => {}\\n }\\n } else {\\n if let Some(value) = default {\\n return Ok(TsLit::Number(Number {\\n span,\\n value: value as _,\\n }));\\n }\\n }\\n\\n Err(())\\n }\\n\\n let id = e.id.clone();\\n\\n let mut default = 0;\\n let mut values = Default::default();\\n let members = e\\n .members\\n .clone()\\n .into_iter()\\n .map(|m| -> Result<_, ()> {\\n let id_span = m.id.span();\\n let val = compute(\\n &e,\\n id_span,\\n &mut values,\\n Some(default),\\n m.init.as_ref().map(|v| &**v),\\n )\\n .map(|val| {\\n match val {\\n TsLit::Number(n) => {\\n default = n.value as i64 + 1;\\n }\\n _ => {}\\n }\\n values.insert(\\n match &m.id {\\n TsEnumMemberId::Ident(i) => i.clone().into_id(),\\n TsEnumMemberId::Str(s) => Ident::new(s.value.clone(), s.span).into_id(),\\n },\\n val.clone(),\\n );\\n\\n match val {\\n TsLit::Number(v) => Expr::Lit(Lit::Num(v)),\\n TsLit::Str(v) => Expr::Lit(Lit::Str(v)),\\n TsLit::Bool(v) => Expr::Lit(Lit::Bool(v)),\\n TsLit::Tpl(v) => {\\n Expr::Lit(Lit::Str(v.quasis.into_iter().next().unwrap().raw))\\n }\\n TsLit::BigInt(v) => Expr::Lit(Lit::BigInt(v)),\\n }\\n })\\n .or_else(|err| match &m.init {\\n None => Err(err),\\n Some(v) => Ok(*v.clone()),\\n })?;\\n\\n Ok((m, val))\\n })\\n .collect::, _>>()\\n .unwrap_or_else(|_| panic!(\"invalid value for enum is detected\"));\\n\\n let is_all_str = members.iter().all(|(_, v)| match v {\\n Expr::Lit(Lit::Str(..)) => true,\\n _ => false,\\n });\\n let no_init_required = is_all_str;\\n let rhs_should_be_name = members.iter().all(|(m, v): &(TsEnumMember, Expr)| match v {\\n Expr::Lit(Lit::Str(s)) => match &m.id {\\n TsEnumMemberId::Ident(i) => i.sym == s.value,\\n TsEnumMemberId::Str(s) => s.value != s.value,\\n },\\n _ => true,\\n });\\n\\n stmts.push(T::from_stmt(\\n CallExpr {\\n span: DUMMY_SP,\\n callee: FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n is_async: false,\\n is_generator: false,\\n type_params: Default::default(),\\n params: vec![Param {\\n span: id.span,\\n decorators: vec![],\\n pat: Pat::Ident(id.clone().into()),\\n }],\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: members\\n .into_iter()\\n .enumerate()\\n .map(|(_, (m, val))| {\\n let value = match m.id {\\n TsEnumMemberId::Str(s) => s,\\n TsEnumMemberId::Ident(i) => Str {\\n span: i.span,\\n value: i.sym,\\n has_escape: false,\\n kind: StrKind::Normal {\\n contains_quote: false,\\n },\\n },\\n };\\n let prop = if no_init_required {\\n Box::new(Expr::Lit(Lit::Str(value.clone())))\\n } else {\\n Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(Expr::Member(\\n MemberExpr {\\n span: DUMMY_SP,\\n obj: id.clone().as_obj(),\\n prop: Box::new(Expr::Lit(Lit::Str(\\n value.clone(),\\n ))),\\n computed: true,\\n },\\n ))),\\n op: op!(\"=\"),\\n right: Box::new(val),\\n }))\\n };\\n\\n // Foo[Foo[\"a\"] = 0] = \"a\";\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(Expr::Member(MemberExpr {\\n obj: id.clone().as_obj(),\\n span: DUMMY_SP,\\n computed: true,\\n\\n // Foo[\"a\"] = 0\\n prop,\\n }))),\\n op: op!(\"=\"),\\n right: if rhs_should_be_name {\\n Box::new(Expr::Lit(Lit::Str(value.clone())))\\n } else {\\n m.init.unwrap_or_else(|| {\\n Box::new(Expr::Lit(Lit::Str(value.clone())))\\n })\\n },\\n }\\n .into_stmt()\\n })\\n .collect(),\\n }),\\n return_type: Default::default(),\\n },\\n }\\n .as_callee(),\\n args: vec![BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Ident(id.clone())),\\n op: op!(\"||\"),\\n right: Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Pat::Ident(id.clone().into()).into()),\\n op: op!(\"=\"),\\n right: Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: vec![],\\n })),\\n })),\\n }\\n .as_arg()],\\n type_args: Default::default(),\\n }\\n .into_stmt(),\\n ))\\n }\\n\\n /// Returns `(var_decl, init)`.\\n fn handle_ts_module(&mut self, module: TsModuleDecl) -> Option<(Option, Stmt)> {\\n if module.global || module.declare {\\n return None;\\n }\\n let module_span = module.span;\\n\\n let module_name = match module.id {\\n TsModuleName::Ident(i) => i,\\n TsModuleName::Str(_) => return None,\\n };\\n let body = module.body?;\\n let mut body = match body {\\n TsNamespaceBody::TsModuleBlock(body) => body,\\n TsNamespaceBody::TsNamespaceDecl(_) => return None,\\n };\\n\\n let mut init_stmts = vec![];\\n\\n let var = self.create_uninit_var(module_name.span, module_name.to_id());\\n\\n // This makes body valid javascript.\\n body.body.visit_mut_with(self);\\n if body.body.is_empty() {\\n return None;\\n }\\n\\n let private_name = private_ident!(module_name.sym.clone());\\n let mut delayed_vars = vec![];\\n\\n for item in body.body {\\n // Drop\\n\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span, decl, ..\\n })) => {\\n let decl_name = match decl {\\n Decl::Class(ref c) => c.ident.clone(),\\n Decl::Fn(ref f) => f.ident.clone(),\\n Decl::Var(v) => {\\n let mut exprs = vec![];\\n for decl in v.decls {\\n let init = match decl.init {\\n Some(v) => v,\\n None => {\\n // We should handle enums\\n\\n match &decl.name {\\n Pat::Ident(name) => {\\n delayed_vars.push(name.id.clone());\\n init_stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: v.kind,\\n declare: false,\\n decls: vec![decl],\\n })))\\n }\\n _ => {}\\n }\\n\\n continue;\\n }\\n };\\n match decl.name {\\n Pat::Ident(name) => {\\n //\\n let left =\\n PatOrExpr::Expr(Box::new(Expr::Member(MemberExpr {\\n span: DUMMY_SP,\\n obj: private_name.clone().as_obj(),\\n prop: Box::new(Expr::Ident(name.id.clone())),\\n computed: false,\\n })));\\n\\n exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left,\\n right: init,\\n })))\\n }\\n _ => {\\n let pat =\\n Box::new(create_prop_pat(&private_name, decl.name));\\n // Destructure the variable.\\n exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(pat),\\n right: init,\\n })))\\n }\\n }\\n }\\n if !exprs.is_empty() {\\n init_stmts.push(Stmt::Expr(ExprStmt {\\n span: DUMMY_SP,\\n expr: if exprs.len() == 1 {\\n exprs.into_iter().next().unwrap()\\n } else {\\n Box::new(Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs,\\n }))\\n },\\n }));\\n }\\n\\n // TODO: Implement this using alias.\\n continue;\\n }\\n Decl::TsInterface(_)\\n | Decl::TsTypeAlias(_)\\n | Decl::TsEnum(_)\\n | Decl::TsModule(_) => continue,\\n };\\n init_stmts.push(Stmt::Decl(decl));\\n\\n //\\n let left = PatOrExpr::Expr(Box::new(Expr::Member(MemberExpr {\\n span: DUMMY_SP,\\n obj: private_name.clone().as_obj(),\\n prop: Box::new(Expr::Ident(decl_name.clone())),\\n computed: false,\\n })));\\n\\n let right = Box::new(Expr::Ident(decl_name));\\n\\n init_stmts.push(Stmt::Expr(ExprStmt {\\n span,\\n expr: Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left,\\n right,\\n })),\\n }))\\n }\\n\\n ModuleItem::Stmt(stmt) => init_stmts.push(stmt),\\n _ => {}\\n }\\n }\\n\\n if !delayed_vars.is_empty() {\\n init_stmts.push(Stmt::Expr(ExprStmt {\\n span: DUMMY_SP,\\n expr: Box::new(Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs: delayed_vars\\n .into_iter()\\n .map(|id| {\\n //\\n let mut prop = id.clone();\\n prop.span.ctxt = SyntaxContext::empty();\\n Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Expr(Box::new(Expr::Member(MemberExpr {\\n span: DUMMY_SP,\\n obj: private_name.clone().as_obj(),\\n prop: Box::new(Expr::Ident(prop)),\\n computed: false,\\n }))),\\n right: Box::new(Expr::Ident(id)),\\n })\\n })\\n .map(Box::new)\\n .collect(),\\n })),\\n }))\\n }\\n\\n let init_fn_expr = FnExpr {\\n ident: None,\\n function: Function {\\n params: vec![Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(private_name.clone().into()),\\n }],\\n decorators: Default::default(),\\n span: DUMMY_SP,\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: init_stmts,\\n }),\\n is_generator: false,\\n is_async: false,\\n type_params: Default::default(),\\n return_type: Default::default(),\\n },\\n };\\n\\n let init_arg = BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Ident(module_name.clone())),\\n op: op!(\"||\"),\\n right: Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(module_name.clone().into()))),\\n right: Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: Default::default(),\\n })),\\n })),\\n };\\n\\n let initializer = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: init_fn_expr.as_callee(),\\n args: vec![init_arg.as_arg()],\\n type_args: Default::default(),\\n }));\\n\\n Some((\\n var.map(|var| {\\n Decl::Var(VarDecl {\\n span: module_span,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: vec![var],\\n })\\n }),\\n Stmt::Expr(ExprStmt {\\n span: DUMMY_SP,\\n expr: initializer,\\n }),\\n ))\\n }\\n}\\n\\nimpl Visit for Strip {\\n fn visit_assign_pat_prop(&mut self, n: &AssignPatProp, _: &dyn Node) {\\n if !self.in_var_pat {\\n n.key.visit_with(n, self);\\n }\\n n.value.visit_with(n, self);\\n }\\n\\n fn visit_assign_prop(&mut self, n: &AssignProp, _: &dyn Node) {\\n n.value.visit_with(n, self);\\n }\\n\\n fn visit_binding_ident(&mut self, n: &BindingIdent, _: &dyn Node) {\\n if !self.in_var_pat {\\n n.visit_children_with(self)\\n }\\n }\\n\\n fn visit_decl(&mut self, n: &Decl, _: &dyn Node) {\\n self.handle_decl(n);\\n\\n let old = self.non_top_level;\\n self.non_top_level = true;\\n // Visit the declaration body and not the identifier. Otherwise\\n // type declarations could be unintentionally marked as concrete\\n // by the visit_ident function above.\\n match n {\\n Decl::Class(class) => {\\n self.decl_names.insert(class.ident.to_id());\\n class.class.visit_with(class, self);\\n }\\n Decl::Fn(f) => {\\n self.decl_names.insert(f.ident.to_id());\\n f.function.visit_with(f, self)\\n }\\n Decl::Var(ref var) => {\\n for decl in &var.decls {\\n self.in_var_pat = true;\\n decl.name.visit_with(decl, self);\\n self.in_var_pat = false;\\n decl.init.visit_with(decl, self);\\n }\\n }\\n Decl::TsEnum(e) => {\\n e.members.visit_with(e, self);\\n }\\n Decl::TsInterface(interface) => {\\n interface.extends.visit_with(interface, self);\\n interface.body.visit_with(interface, self);\\n }\\n Decl::TsModule(module) => {\\n module.body.visit_with(module, self);\\n }\\n Decl::TsTypeAlias(alias) => {\\n alias.type_params.visit_with(alias, self);\\n alias.type_ann.visit_with(alias, self);\\n }\\n }\\n self.non_top_level = old;\\n }\\n\\n fn visit_ident(&mut self, n: &Ident, _: &dyn Node) {\\n let is_type_only_export = self.is_type_only_export;\\n let entry = self.scope.referenced_idents.entry(n.to_id()).or_default();\\n entry.has_concrete |= !is_type_only_export;\\n\\n n.visit_children_with(self);\\n }\\n\\n fn visit_import_decl(&mut self, n: &ImportDecl, _: &dyn Node) {\\n macro_rules! store {\\n ($i:expr) => {{\\n self.scope\\n .referenced_idents\\n .entry(($i.sym.clone(), $i.span.ctxt()))\\n .or_default();\\n if n.type_only {\\n self.scope.decls.entry($i.to_id()).or_default().has_type = true;\\n }\\n }};\\n }\\n for s in &n.specifiers {\\n match *s {\\n ImportSpecifier::Default(ref import) => store!(import.local),\\n ImportSpecifier::Named(ref import) => store!(import.local),\\n ImportSpecifier::Namespace(ref import) => store!(import.local),\\n }\\n }\\n }\\n\\n fn visit_member_expr(&mut self, n: &MemberExpr, _: &dyn Node) {\\n n.obj.visit_with(n, self);\\n if n.computed {\\n n.prop.visit_with(n, self);\\n }\\n }\\n\\n fn visit_module_items(&mut self, n: &[ModuleItem], _: &dyn Node) {\\n let old = self.non_top_level;\\n self.non_top_level = false;\\n n.iter().for_each(|n| {\\n n.visit_with(&Invalid { span: DUMMY_SP }, self);\\n });\\n self.non_top_level = old;\\n }\\n\\n fn visit_named_export(&mut self, export: &NamedExport, _: &dyn Node) {\\n let old = self.is_type_only_export;\\n self.is_type_only_export = export.type_only;\\n export.visit_children_with(self);\\n self.is_type_only_export = old;\\n }\\n\\n fn visit_prop_name(&mut self, n: &PropName, _: &dyn Node) {\\n match n {\\n PropName::Computed(e) => e.visit_with(n, self),\\n _ => {}\\n }\\n }\\n\\n fn visit_stmts(&mut self, n: &[Stmt], _: &dyn Node) {\\n let old = self.non_top_level;\\n self.non_top_level = true;\\n n.iter()\\n .for_each(|n| n.visit_with(&Invalid { span: DUMMY_SP }, self));\\n self.non_top_level = old;\\n }\\n\\n fn visit_ts_entity_name(&mut self, name: &TsEntityName, _: &dyn Node) {\\n match *name {\\n TsEntityName::Ident(ref i) => {\\n let entry = self\\n .scope\\n .referenced_idents\\n .entry((i.sym.clone(), i.span.ctxt()))\\n .or_default();\\n entry.has_type = true;\\n }\\n TsEntityName::TsQualifiedName(ref q) => q.left.visit_with(&*q, self),\\n }\\n }\\n}\\n\\nmacro_rules! type_to_none {\\n ($name:ident, $T:ty) => {\\n fn $name(&mut self, node: &mut Option<$T>) {\\n *node = None;\\n }\\n };\\n}\\n\\nimpl VisitMut for Strip {\\n fn visit_mut_block_stmt_or_expr(&mut self, n: &mut BlockStmtOrExpr) {\\n match n {\\n BlockStmtOrExpr::Expr(expr) if expr.is_class() => {\\n let span = expr.span();\\n\\n let ClassExpr { ident, class } = expr.take().class().unwrap();\\n let orig_ident = ident.clone();\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_class\"));\\n let (decl, extra_exprs) = self.fold_class_as_decl(ident.clone(), orig_ident, class);\\n let mut stmts = vec![];\\n stmts.push(Stmt::Decl(decl));\\n stmts.extend(\\n extra_exprs\\n .into_iter()\\n .map(|e| e.into_stmt())\\n .collect::>(),\\n );\\n stmts.push(Stmt::Return(ReturnStmt {\\n span,\\n arg: Some(Box::new(Expr::Ident(ident))),\\n }));\\n *n = BlockStmtOrExpr::BlockStmt(BlockStmt {\\n span: n.span(),\\n stmts,\\n });\\n }\\n _ => n.visit_mut_children_with(self),\\n };\\n }\\n\\n fn visit_mut_array_pat(&mut self, n: &mut ArrayPat) {\\n n.visit_mut_children_with(self);\\n n.optional = false;\\n }\\n\\n fn visit_mut_constructor(&mut self, n: &mut Constructor) {\\n n.visit_mut_children_with(self);\\n\\n let mut assign_exprs = vec![];\\n\\n n.params.map_with_mut(|params| {\\n params.move_map(|param| match param {\\n ParamOrTsParamProp::Param(..) => param,\\n ParamOrTsParamProp::TsParamProp(param) => {\\n let (ident, param) = match param.param {\\n TsParamPropParam::Ident(i) => (\\n i.clone(),\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(i),\\n },\\n ),\\n TsParamPropParam::Assign(AssignPat {\\n span, left, right, ..\\n }) if left.is_ident() => {\\n let i = left.ident().unwrap();\\n\\n (\\n i.clone(),\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Assign(AssignPat {\\n span,\\n left: Box::new(Pat::Ident(i)),\\n right,\\n type_ann: None,\\n }),\\n },\\n )\\n }\\n _ => unreachable!(\"destructuring pattern inside TsParameterProperty\"),\\n };\\n let assign_expr = Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n ThisExpr { span: DUMMY_SP }.make_member(ident.id.clone()),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(Expr::Ident(ident.id)),\\n }));\\n assign_exprs.push(assign_expr);\\n\\n ParamOrTsParamProp::Param(param)\\n }\\n })\\n });\\n\\n inject_after_super(n, assign_exprs);\\n }\\n\\n fn visit_mut_expr(&mut self, n: &mut Expr) {\\n let mut stack = vec![n];\\n loop {\\n let mut new_stack = vec![];\\n for expr in stack {\\n let res = self.handle_expr(expr);\\n\\n new_stack.extend(res)\\n }\\n\\n if new_stack.is_empty() {\\n return;\\n }\\n\\n stack = new_stack;\\n }\\n }\\n\\n fn visit_mut_ident(&mut self, i: &mut Ident) {\\n i.optional = false;\\n i.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_if_stmt(&mut self, s: &mut IfStmt) {\\n s.visit_mut_children_with(self);\\n let span = s.span;\\n\\n s.cons.map_with_mut(|cons| match *cons {\\n Stmt::Decl(Decl::TsEnum(e)) => {\\n let mut stmts = vec![];\\n self.handle_enum(e, &mut stmts);\\n Box::new(Stmt::Block(BlockStmt { span, stmts }))\\n }\\n _ => cons,\\n });\\n\\n s.alt.map_with_mut(|alt| {\\n alt.map(|s| match *s {\\n Stmt::Decl(Decl::TsEnum(e)) => {\\n let mut stmts = vec![];\\n self.handle_enum(e, &mut stmts);\\n Box::new(Stmt::Block(BlockStmt { span, stmts }))\\n }\\n _ => s,\\n })\\n })\\n }\\n\\n fn visit_mut_import_decl(&mut self, import: &mut ImportDecl) {\\n if &*import.src.value == \"react\" {\\n return;\\n }\\n\\n self.is_side_effect_import = import.specifiers.is_empty();\\n\\n import.specifiers.retain(|s| match *s {\\n ImportSpecifier::Named(ImportNamedSpecifier {\\n ref is_type_only, ..\\n }) if *is_type_only => false,\\n ImportSpecifier::Default(ImportDefaultSpecifier { ref local, .. })\\n | ImportSpecifier::Named(ImportNamedSpecifier { ref local, .. })\\n | ImportSpecifier::Namespace(ImportStarAsSpecifier { ref local, .. }) => {\\n // If the import is shadowed by a concrete local declaration, TSC\\n // assumes the import is a type and removes it.\\n let decl = self.scope.decls.get(&local.to_id());\\n match decl {\\n Some(&DeclInfo {\\n has_concrete: true, ..\\n }) => return false,\\n _ => {}\\n }\\n // If no shadowed declaration, check if the import is referenced.\\n let entry = self.scope.referenced_idents.get(&local.to_id());\\n match entry {\\n Some(&DeclInfo {\\n has_concrete: false,\\n ..\\n }) => false,\\n _ => true,\\n }\\n }\\n });\\n\\n if import.specifiers.is_empty() && !self.is_side_effect_import {\\n self.is_side_effect_import = match self.config.import_not_used_as_values {\\n ImportsNotUsedAsValues::Remove => false,\\n ImportsNotUsedAsValues::Preserve => true,\\n };\\n }\\n }\\n\\n fn visit_mut_object_pat(&mut self, pat: &mut ObjectPat) {\\n pat.visit_mut_children_with(self);\\n pat.optional = false;\\n }\\n\\n fn visit_mut_private_prop(&mut self, prop: &mut PrivateProp) {\\n prop.visit_mut_children_with(self);\\n prop.readonly = false;\\n }\\n\\n fn visit_mut_class_prop(&mut self, prop: &mut ClassProp) {\\n prop.visit_mut_children_with(self);\\n prop.readonly = false;\\n }\\n\\n fn visit_mut_stmt(&mut self, stmt: &mut Stmt) {\\n stmt.visit_mut_children_with(self);\\n\\n match stmt {\\n Stmt::Decl(ref decl) => match decl {\\n Decl::TsInterface(..)\\n | Decl::TsTypeAlias(..)\\n | Decl::Var(VarDecl { declare: true, .. })\\n | Decl::Class(ClassDecl { declare: true, .. })\\n | Decl::Fn(FnDecl { declare: true, .. }) => {\\n let span = decl.span();\\n *stmt = Stmt::Empty(EmptyStmt { span })\\n }\\n\\n _ => {}\\n },\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_stmts(&mut self, orig: &mut Vec) {\\n self.visit_mut_stmt_like(orig);\\n // Second pass\\n let mut stmts = Vec::with_capacity(orig.len());\\n for mut item in take(orig) {\\n self.is_side_effect_import = false;\\n match item {\\n Stmt::Empty(..) => continue,\\n\\n Stmt::Decl(Decl::TsModule(module)) => {\\n let (decl, init) = match self.handle_ts_module(module) {\\n Some(v) => v,\\n None => continue,\\n };\\n stmts.extend(decl.map(Stmt::Decl));\\n stmts.push(init)\\n }\\n\\n Stmt::Decl(Decl::TsEnum(e)) => {\\n // var Foo;\\n // (function (Foo) {\\n // Foo[Foo[\"a\"] = 0] = \"a\";\\n // })(Foo || (Foo = {}));\\n\\n if let Some(var) = self.create_uninit_var(e.span, e.id.to_id()) {\\n stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: vec![var],\\n })));\\n }\\n\\n self.handle_enum(e, &mut stmts)\\n }\\n\\n // Strip out ts-only extensions\\n Stmt::Decl(Decl::Fn(FnDecl {\\n function: Function { body: None, .. },\\n ..\\n }))\\n | Stmt::Decl(Decl::TsTypeAlias(..)) => continue,\\n\\n _ => {\\n item.visit_mut_with(self);\\n stmts.push(item);\\n }\\n };\\n }\\n\\n *orig = stmts\\n }\\n\\n fn visit_mut_ts_interface_decl(&mut self, n: &mut TsInterfaceDecl) {\\n n.type_params = None;\\n }\\n\\n fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {\\n node.type_params = None;\\n }\\n\\n type_to_none!(visit_mut_opt_ts_type, Box);\\n type_to_none!(visit_mut_opt_ts_type_ann, TsTypeAnn);\\n type_to_none!(visit_mut_opt_ts_type_param_decl, TsTypeParamDecl);\\n type_to_none!(\\n visit_mut_opt_ts_type_param_instantiation,\\n TsTypeParamInstantiation\\n );\\n\\n fn visit_mut_class_members(&mut self, members: &mut Vec) {\\n members.retain(|member| match *member {\\n ClassMember::TsIndexSignature(..) => false,\\n ClassMember::Constructor(Constructor { body: None, .. }) => false,\\n ClassMember::Method(ClassMethod {\\n is_abstract: true, ..\\n })\\n | ClassMember::Method(ClassMethod {\\n function: Function { body: None, .. },\\n ..\\n }) => false,\\n ClassMember::PrivateMethod(PrivateMethod {\\n is_abstract: true, ..\\n })\\n | ClassMember::PrivateMethod(PrivateMethod {\\n function: Function { body: None, .. },\\n ..\\n }) => false,\\n ClassMember::ClassProp(ClassProp {\\n value: None,\\n ref decorators,\\n ..\\n }) if decorators.is_empty() && !self.config.use_define_for_class_fields => false,\\n\\n _ => true,\\n });\\n\\n members.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_opt_accessibility(&mut self, n: &mut Option) {\\n *n = None;\\n }\\n\\n /// Remove `this` from parameter list\\n fn visit_mut_params(&mut self, params: &mut Vec) {\\n params.visit_mut_children_with(self);\\n\\n params.retain(|param| match param.pat {\\n Pat::Ident(BindingIdent {\\n id:\\n Ident {\\n sym: js_word!(\"this\"),\\n ..\\n },\\n ..\\n }) => false,\\n _ => true,\\n });\\n }\\n\\n fn visit_mut_module(&mut self, module: &mut Module) {\\n let was_module = module.body.iter().any(|item| match item {\\n ModuleItem::ModuleDecl(..) => true,\\n _ => false,\\n });\\n\\n module.visit_mut_children_with(self);\\n if !self.uninitialized_vars.is_empty() {\\n prepend(\\n &mut module.body,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: take(&mut self.uninitialized_vars),\\n declare: false,\\n }))\\n .into(),\\n );\\n }\\n\\n let is_module = module.body.iter().any(|item| match item {\\n ModuleItem::ModuleDecl(..) => true,\\n _ => false,\\n });\\n\\n // Create `export {}` to preserve module context, just like tsc.\\n //\\n // See https://github.com/swc-project/swc/issues/1698\\n if was_module\\n && !is_module\\n && !self.config.no_empty_export\\n && module.body.iter().all(|item| match item {\\n ModuleItem::ModuleDecl(_) => false,\\n ModuleItem::Stmt(_) => true,\\n })\\n {\\n module\\n .body\\n .push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span: module.span,\\n specifiers: vec![],\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )))\\n }\\n }\\n\\n fn visit_mut_script(&mut self, n: &mut Script) {\\n n.visit_mut_children_with(self);\\n if !self.uninitialized_vars.is_empty() {\\n prepend(\\n &mut n.body,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: take(&mut self.uninitialized_vars),\\n declare: false,\\n }))\\n .into(),\\n );\\n }\\n }\\n\\n fn visit_mut_module_items(&mut self, items: &mut Vec) {\\n self.visit_mut_stmt_like(items);\\n items.visit_with(&Invalid { span: DUMMY_SP }, self);\\n\\n let mut stmts = Vec::with_capacity(items.len());\\n for mut item in take(items) {\\n self.is_side_effect_import = false;\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl: Decl::TsModule(module),\\n ..\\n })) => {\\n let (decl, init) = match self.handle_ts_module(module) {\\n Some(v) => v,\\n None => continue,\\n };\\n\\n stmts.extend(decl.map(|decl| {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl { span, decl }))\\n }));\\n stmts.push(init.into())\\n }\\n\\n ModuleItem::Stmt(Stmt::Decl(Decl::TsModule(module))) => {\\n let (decl, init) = match self.handle_ts_module(module) {\\n Some(v) => v,\\n None => continue,\\n };\\n stmts.extend(decl.map(Stmt::Decl).map(ModuleItem::Stmt));\\n stmts.push(init.into())\\n }\\n\\n // Strip out ts-only extensions\\n ModuleItem::Stmt(Stmt::Decl(Decl::Fn(FnDecl {\\n function: Function { body: None, .. },\\n ..\\n })))\\n | ModuleItem::Stmt(Stmt::Decl(Decl::TsInterface(..)))\\n | ModuleItem::Stmt(Stmt::Decl(Decl::TsTypeAlias(..)))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::TsInterface(..),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::TsTypeAlias(..),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl:\\n Decl::Fn(FnDecl {\\n function: Function { body: None, .. },\\n ..\\n }),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl:\\n DefaultDecl::Fn(FnExpr {\\n function: Function { body: None, .. },\\n ..\\n }),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl: DefaultDecl::TsInterfaceDecl(..),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::TsNamespaceExport(..))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Class(ClassDecl { declare: true, .. }),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Var(VarDecl { declare: true, .. }),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::TsEnum(TsEnumDecl { declare: true, .. }),\\n ..\\n }))\\n | ModuleItem::Stmt(Stmt::Decl(Decl::Class(ClassDecl { declare: true, .. })))\\n | ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl { declare: true, .. }))) => {\\n continue\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::TsImportEquals(TsImportEqualsDecl {\\n span,\\n declare: false,\\n is_export: false,\\n is_type_only: false,\\n id,\\n module_ref:\\n TsModuleRef::TsExternalModuleRef(TsExternalModuleRef { span: _, expr }),\\n })) => {\\n let default = VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(id.into()),\\n init: Some(Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"require\").as_callee(),\\n args: vec![expr.as_arg()],\\n type_args: None,\\n }))),\\n definite: false,\\n };\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span,\\n kind: VarDeclKind::Const,\\n declare: false,\\n decls: vec![default],\\n }))))\\n }\\n\\n // Always strip type only import / exports\\n ModuleItem::Stmt(Stmt::Empty(..))\\n | ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {\\n type_only: true, ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {\\n type_only: true,\\n ..\\n })) => continue,\\n\\n ModuleItem::ModuleDecl(ModuleDecl::Import(mut i)) => {\\n i.visit_mut_with(self);\\n\\n if self.is_side_effect_import || !i.specifiers.is_empty() {\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::Import(i)));\\n }\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::TsEnum(e),\\n ..\\n })) => {\\n if let Some(var) = self.create_uninit_var(e.span, e.id.to_id()) {\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span: e.span,\\n decl: Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: vec![var],\\n }),\\n })));\\n }\\n\\n self.handle_enum(e, &mut stmts)\\n }\\n ModuleItem::Stmt(Stmt::Decl(Decl::TsEnum(e))) => {\\n // var Foo;\\n // (function (Foo) {\\n // Foo[Foo[\"a\"] = 0] = \"a\";\\n // })(Foo || (Foo = {}));\\n\\n if let Some(var) = self.create_uninit_var(e.span, e.id.to_id()) {\\n stmts.push(\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: vec![var],\\n }))\\n .into(),\\n );\\n }\\n self.handle_enum(e, &mut stmts)\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(ExportDefaultExpr {\\n ref expr,\\n ..\\n })) if expr.is_ident() => {\\n let i = expr.clone().ident().unwrap();\\n // type MyType = string;\\n // export default MyType;\\n\\n let preserve = if let Some(decl_info) = self.scope.decls.get(&i.to_id()) {\\n decl_info.has_concrete\\n } else {\\n true\\n };\\n\\n if preserve {\\n stmts.push(item)\\n }\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::TsImportEquals(import)) => {\\n if !import.is_type_only {\\n let var = Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(import.id.into()),\\n init: Some(Box::new(module_ref_to_expr(import.module_ref))),\\n definite: false,\\n }],\\n declare: false,\\n });\\n if import.is_export {\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(\\n ExportDecl {\\n span: DUMMY_SP,\\n decl: var,\\n },\\n )));\\n } else {\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(var)));\\n }\\n }\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::TsExportAssignment(export)) => {\\n stmts.push(ModuleItem::Stmt(Stmt::Expr(ExprStmt {\\n span: export.span,\\n expr: Box::new(Expr::Assign(AssignExpr {\\n span: export.span,\\n left: PatOrExpr::Expr(member_expr!(DUMMY_SP, module.exports)),\\n op: op!(\"=\"),\\n right: export.expr,\\n })),\\n })));\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(mut export)) => {\\n // if specifier become empty, we remove export statement.\\n\\n if export.type_only {\\n export.specifiers.clear();\\n }\\n export.specifiers.retain(|s| match *s {\\n ExportSpecifier::Named(ExportNamedSpecifier {\\n ref orig,\\n ref is_type_only,\\n ..\\n }) => {\\n if *is_type_only {\\n false\\n } else if let Some(e) = self.scope.decls.get(&orig.to_id()) {\\n e.has_concrete\\n } else {\\n true\\n }\\n }\\n _ => true,\\n });\\n if export.specifiers.is_empty() {\\n continue;\\n }\\n\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(\\n NamedExport { ..export },\\n )))\\n }\\n\\n _ => {\\n item.visit_mut_with(self);\\n stmts.push(item)\\n }\\n };\\n }\\n\\n *items = stmts;\\n }\\n\\n fn visit_mut_var_declarator(&mut self, d: &mut VarDeclarator) {\\n d.visit_mut_children_with(self);\\n d.definite = false;\\n }\\n}\\n\\nfn module_ref_to_expr(r: TsModuleRef) -> Expr {\\n match r {\\n TsModuleRef::TsEntityName(name) => ts_entity_name_to_expr(name),\\n _ => unimplemented!(\"export import A = B where B != TsEntityName\\\\nB: {:?}\", r),\\n }\\n}\\n\\nfn ts_entity_name_to_expr(n: TsEntityName) -> Expr {\\n match n {\\n TsEntityName::Ident(i) => i.into(),\\n TsEntityName::TsQualifiedName(q) => {\\n let TsQualifiedName { left, right } = *q;\\n\\n MemberExpr {\\n span: DUMMY_SP,\\n obj: ExprOrSuper::Expr(Box::new(ts_entity_name_to_expr(left))),\\n prop: Box::new(right.into()),\\n computed: false,\\n }\\n .into()\\n }\\n }\\n}\\n\\nfn create_prop_pat(obj: &Ident, pat: Pat) -> Pat {\\n match pat {\\n Pat::Invalid(_) => pat,\\n\\n Pat::Ident(i) => Pat::Expr(Box::new(Expr::Member(MemberExpr {\\n span: i.id.span,\\n obj: obj.clone().as_obj(),\\n prop: Box::new(Expr::Ident(i.id)),\\n computed: false,\\n }))),\\n Pat::Array(p) => Pat::Array(ArrayPat {\\n elems: p\\n .elems\\n .into_iter()\\n .map(|elem| Some(create_prop_pat(obj, elem?)))\\n .collect(),\\n ..p\\n }),\\n Pat::Rest(_) => {\\n todo!(\"Rest pattern in an exported variable from namespace\")\\n }\\n Pat::Object(p) => Pat::Object(ObjectPat {\\n props: p\\n .props\\n .into_iter()\\n .map(|prop| match prop {\\n ObjectPatProp::KeyValue(kv) => ObjectPatProp::KeyValue(KeyValuePatProp {\\n value: Box::new(create_prop_pat(obj, *kv.value)),\\n ..kv\\n }),\\n ObjectPatProp::Assign(..) => prop,\\n ObjectPatProp::Rest(_) => {\\n todo!(\"Rest pattern property in an exported variable from namespace\")\\n }\\n })\\n .collect(),\\n ..p\\n }),\\n Pat::Assign(p) => Pat::Assign(AssignPat {\\n left: Box::new(create_prop_pat(obj, *p.left)),\\n ..p\\n }),\\n // TODO\\n Pat::Expr(..) => pat,\\n }\\n}\\n',\n", + " 'content_id': 'bb30713e37a2fc064b03200077868e139c8cbb49',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 158,\n", + " 'path': '/ecmascript/transforms/typescript/src/strip.rs',\n", + " 'size': 80621,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.48069830341775266,\n", + " 'avg_line_length': 27.54035087719298,\n", + " 'blob_id': '67ac23e2c6eae9aa266683fcd3f2eed3619f892e',\n", + " 'content': 'use self::preserver::idents_to_preserve;\\nuse super::compute_char_freq::CharFreqInfo;\\nuse crate::{\\n analyzer::{analyze, ProgramData},\\n marks::Marks,\\n option::MangleOptions,\\n util::base54::incr_base54,\\n};\\nuse rustc_hash::{FxHashMap, FxHashSet};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::SyntaxContext;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};\\n\\nmod preserver;\\n\\npub(crate) fn name_mangler(\\n options: MangleOptions,\\n _char_freq_info: CharFreqInfo,\\n _marks: Marks,\\n) -> impl VisitMut {\\n Mangler {\\n options,\\n n: 0,\\n private_n: 0,\\n preserved: Default::default(),\\n preserved_symbols: Default::default(),\\n renamed: Default::default(),\\n renamed_private: Default::default(),\\n data: Default::default(),\\n }\\n}\\n\\n#[derive(Debug)]\\nstruct Mangler {\\n options: MangleOptions,\\n n: usize,\\n private_n: usize,\\n\\n preserved: FxHashSet,\\n preserved_symbols: FxHashSet,\\n renamed: FxHashMap,\\n renamed_private: FxHashMap,\\n data: Option,\\n}\\n\\nimpl Mangler {\\n fn rename(&mut self, i: &mut Ident) -> bool {\\n match i.sym {\\n js_word!(\"arguments\") => return false,\\n _ => {}\\n }\\n\\n if self.preserved.contains(&i.to_id()) {\\n return false;\\n }\\n\\n if let Some(var) = self.data.as_ref().unwrap().vars.get(&i.to_id()) {\\n if !var.declared {\\n return false;\\n }\\n }\\n\\n if let Some(v) = self.renamed.get(&i.to_id()) {\\n i.span.ctxt = SyntaxContext::empty();\\n i.sym = v.clone();\\n return true;\\n }\\n\\n loop {\\n let sym = incr_base54(&mut self.n);\\n\\n let sym: JsWord = sym.into();\\n if self.preserved_symbols.contains(&sym) {\\n continue;\\n }\\n\\n self.renamed.insert(i.to_id(), sym.clone());\\n\\n i.sym = sym.clone();\\n i.span.ctxt = SyntaxContext::empty();\\n break;\\n }\\n\\n true\\n }\\n\\n fn rename_private(&mut self, private_name: &mut PrivateName) {\\n let id = private_name.id.to_id();\\n\\n let new_sym = if let Some(cached) = self.renamed_private.get(&id) {\\n cached.clone()\\n } else {\\n loop {\\n let sym = incr_base54(&mut self.private_n);\\n\\n let sym: JsWord = sym.into();\\n\\n self.renamed_private.insert(id.clone(), sym.clone());\\n\\n break sym;\\n }\\n };\\n\\n private_name.id.sym = new_sym;\\n }\\n}\\n\\nimpl VisitMut for Mangler {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_class_decl(&mut self, n: &mut ClassDecl) {\\n self.rename(&mut n.ident);\\n\\n n.class.visit_mut_with(self);\\n }\\n fn visit_mut_export_named_specifier(&mut self, n: &mut ExportNamedSpecifier) {\\n if n.exported.is_none() {\\n n.exported = Some(n.orig.clone());\\n }\\n\\n self.rename(&mut n.orig);\\n }\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n e.visit_mut_children_with(self);\\n\\n match e {\\n Expr::Ident(i) => {\\n self.rename(i);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_fn_decl(&mut self, n: &mut FnDecl) {\\n self.rename(&mut n.ident);\\n n.function.visit_mut_with(self);\\n }\\n\\n fn visit_mut_import_default_specifier(&mut self, n: &mut ImportDefaultSpecifier) {\\n self.rename(&mut n.local);\\n }\\n\\n fn visit_mut_import_named_specifier(&mut self, n: &mut ImportNamedSpecifier) {\\n match &n.imported {\\n Some(..) => {}\\n None => {\\n n.imported = Some(n.local.clone());\\n }\\n }\\n\\n self.rename(&mut n.local);\\n }\\n\\n fn visit_mut_import_star_as_specifier(&mut self, n: &mut ImportStarAsSpecifier) {\\n self.rename(&mut n.local);\\n }\\n\\n fn visit_mut_labeled_stmt(&mut self, n: &mut LabeledStmt) {\\n n.body.visit_mut_with(self);\\n }\\n\\n fn visit_mut_member_expr(&mut self, n: &mut MemberExpr) {\\n n.obj.visit_mut_with(self);\\n\\n if n.computed {\\n n.prop.visit_mut_with(self);\\n } else {\\n match &*n.prop {\\n Expr::PrivateName(..) => {\\n n.prop.visit_mut_with(self);\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_mut_module(&mut self, n: &mut Module) {\\n let data = analyze(&*n, None);\\n self.data = Some(data);\\n self.preserved = idents_to_preserve(self.options.clone(), n);\\n self.preserved_symbols = self.preserved.iter().map(|v| v.0.clone()).collect();\\n n.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_named_export(&mut self, n: &mut NamedExport) {\\n if n.src.is_some() {\\n return;\\n }\\n\\n n.visit_mut_children_with(self)\\n }\\n\\n fn visit_mut_object_pat_prop(&mut self, n: &mut ObjectPatProp) {\\n match n {\\n ObjectPatProp::Assign(AssignPatProp {\\n value: None, key, ..\\n }) => {\\n let key_span = key.span.with_ctxt(SyntaxContext::empty());\\n let orig = key.sym.clone();\\n\\n if self.rename(key) {\\n *n = ObjectPatProp::KeyValue(KeyValuePatProp {\\n key: PropName::Ident(Ident::new(orig, key_span)),\\n value: Box::new(Pat::Ident(key.clone().into())),\\n });\\n }\\n }\\n\\n ObjectPatProp::Assign(p) => {\\n let key_span = p.key.span.with_ctxt(SyntaxContext::empty());\\n let orig = p.key.sym.clone();\\n\\n if self.rename(&mut p.key) {\\n if let Some(right) = p.value.take() {\\n *n = ObjectPatProp::KeyValue(KeyValuePatProp {\\n key: PropName::Ident(Ident::new(orig, key_span)),\\n value: Box::new(Pat::Assign(AssignPat {\\n span: p.span,\\n left: Box::new(Pat::Ident(p.key.clone().into())),\\n right,\\n type_ann: None,\\n })),\\n });\\n } else {\\n *n = ObjectPatProp::KeyValue(KeyValuePatProp {\\n key: PropName::Ident(Ident::new(orig, key_span)),\\n value: Box::new(Pat::Ident(p.key.clone().into())),\\n });\\n }\\n }\\n }\\n\\n _ => {\\n n.visit_mut_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_mut_pat(&mut self, n: &mut Pat) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n Pat::Ident(i) => {\\n self.rename(&mut i.id);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_private_name(&mut self, private_name: &mut PrivateName) {\\n if !self.options.keep_private_props {\\n self.rename_private(private_name);\\n }\\n }\\n\\n fn visit_mut_prop(&mut self, n: &mut Prop) {\\n match n {\\n Prop::Shorthand(p) => {\\n let span = p.span.with_ctxt(SyntaxContext::empty());\\n let orig = p.sym.clone();\\n\\n if self.rename(p) {\\n *n = Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(Ident::new(orig, span)),\\n value: Box::new(Expr::Ident(p.clone())),\\n });\\n }\\n }\\n _ => {\\n n.visit_mut_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_mut_script(&mut self, n: &mut Script) {\\n let data = analyze(&*n, None);\\n self.data = Some(data);\\n self.preserved = idents_to_preserve(self.options.clone(), n);\\n self.preserved_symbols = self.preserved.iter().map(|v| v.0.clone()).collect();\\n n.visit_mut_children_with(self);\\n }\\n}\\n',\n", + " 'content_id': '09581b9be364cf84db28c76bb61e1ba97e34aec0',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 86,\n", + " 'path': '/ecmascript/minifier/src/pass/mangle_names/mod.rs',\n", + " 'size': 8134,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6271551724137931,\n", + " 'avg_line_length': 45.4,\n", + " 'blob_id': '1ad6a78c46ba751b413f6af4d355facfb5df95fa',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_typescript/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_typescript\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.46.1\"\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1.0.118\", features = [\"derive\"]}\\nswc_atoms = {version = \"0.2\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\n\\n[dev-dependencies]\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../../codegen\"}\\nswc_ecma_transforms_compat = {version = \"0.40.0\", path = \"../compat\"}\\nswc_ecma_transforms_module = {version = \"0.44.0\", path = \"../module\"}\\nswc_ecma_transforms_proposal = {version = \"0.44.0\", path = \"../proposal/\"}\\nswc_ecma_transforms_testing = {version = \"0.36.0\", path = \"../testing\"}\\ntesting = {version = \"0.14.0\", path = \"../../../testing\"}\\nwalkdir = \"2.3.1\"\\n',\n", + " 'content_id': '37b905cbd216d36ee73909bc5c2fde9f3b8a819b',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/transforms/typescript/Cargo.toml',\n", + " 'size': 1392,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6005665722379604,\n", + " 'avg_line_length': 29.257142857142856,\n", + " 'blob_id': 'b5a3db779d2e5d32a6c41dba73da6a0e3f008d33',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\nbuild = \"build.rs\"\\nedition = \"2018\"\\nexclude = [\"artifacts.json\", \"index.node\"]\\nlicense = \"MIT\"\\nname = \"node\"\\npublish = false\\nversion = \"0.1.0\"\\n\\n[lib]\\ncrate-type = [\"cdylib\"]\\n\\n[build-dependencies]\\nnapi-build = {version = \"1\"}\\n\\n[dependencies]\\nanyhow = \"1\"\\nbacktrace = \"0.3\"\\nnapi = {version = \"1\", features = [\"serde-json\"]}\\nnapi-derive = {version = \"1\"}\\npath-clean = \"0.1\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1\", features = [\"derive\"]}\\nserde_json = {version = \"1\", features = [\"unbounded_depth\"]}\\nswc = {path = \"../../\", features = [\"wrong-target\"]}\\nswc_atoms = {version = \"0.2.4\", path = \"../../atoms\"}\\nswc_bundler = {path = \"../../bundler\"}\\nswc_common = {path = \"../../common\", features = [\"sourcemap\"]}\\nswc_ecma_ast = {path = \"../../ecmascript/ast\"}\\nswc_ecma_loader = {path = \"../../ecmascript/loader\"}\\nswc_ecma_parser = {path = \"../../ecmascript/parser\"}\\nswc_node_base = {path = \"../base\"}\\nswc_node_bundler = {path = \"../bundler\"}\\ntracing = {version = \"0.1.28\", features = [\"release_max_level_off\"]}\\n',\n", + " 'content_id': '5f250c79e1c8250a636bc2791950ee19eee894c4',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 68,\n", + " 'path': '/node/binding/Cargo.toml',\n", + " 'size': 1059,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6254777070063694,\n", + " 'avg_line_length': 40.31578947368421,\n", + " 'blob_id': 'bc97d5a400eca2cd710bb9473f1ad2db83eaedd1',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_proposal/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_proposal\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.44.0\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[features]\\ndefault = []\\nmulti-module = [\"swc_ecma_loader\"]\\n\\n[dependencies]\\neither = \"1.6.1\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1.0.118\", features = [\"derive\"]}\\nsmallvec = \"1.6.0\"\\nswc_atoms = {version = \"0.2\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_loader = {version = \"0.20.0\", path = \"../../loader\", optional = true}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_transforms_classes = {version = \"0.21.0\", path = \"../classes\"}\\nswc_ecma_transforms_macros = {version = \"0.2.1\", path = \"../macros\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\n\\n[dev-dependencies]\\nserde_json = \"1.0.66\"\\nswc_ecma_transforms_compat = {version = \"0.40.0\", path = \"../compat\"}\\nswc_ecma_transforms_module = {version = \"0.44.0\", path = \"../module\"}\\nswc_ecma_transforms_testing = {version = \"0.36.0\", path = \"../testing\"}\\ntesting = {version = \"0.14.0\", path = \"../../../testing\"}\\n',\n", + " 'content_id': 'c6b12af9aed8dcc6f3fa4c28d2950f5ee2a07806',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/transforms/proposal/Cargo.toml',\n", + " 'size': 1570,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.45276292335115864,\n", + " 'avg_line_length': 30.416,\n", + " 'blob_id': '15bce7b8a18a42f009bf0288d492e9ca9a163f37',\n", + " 'content': 'use rustc_hash::FxHashSet;\\nuse swc_atoms::JsWord;\\nuse swc_common::Spanned;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::quote_str;\\nuse swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\n\\npub fn duplicate_keys() -> impl Fold + VisitMut {\\n as_folder(DuplicateKeys)\\n}\\n\\nstruct DuplicateKeys;\\n\\nimpl VisitMut for DuplicateKeys {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_expr(&mut self, expr: &mut Expr) {\\n expr.visit_mut_children_with(self);\\n\\n match expr {\\n Expr::Object(ObjectLit { props, .. }) => {\\n let mut folder = PropFolder::default();\\n props.visit_mut_with(&mut folder);\\n }\\n _ => {}\\n }\\n }\\n}\\n\\n#[derive(Default)]\\nstruct PropFolder {\\n getter_props: FxHashSet,\\n setter_props: FxHashSet,\\n}\\n\\nimpl VisitMut for PropFolder {\\n noop_visit_mut_type!();\\n\\n /// Noop\\n fn visit_mut_expr(&mut self, _: &mut Expr) {}\\n\\n fn visit_mut_prop(&mut self, prop: &mut Prop) {\\n match prop {\\n Prop::Shorthand(ident) => {\\n //\\n if !self.getter_props.insert(ident.sym.clone())\\n || !self.setter_props.insert(ident.sym.clone())\\n {\\n *prop = Prop::KeyValue(KeyValueProp {\\n key: PropName::Computed(ComputedPropName {\\n span: ident.span,\\n expr: Box::new(Expr::Lit(Lit::Str(quote_str!(ident.sym.clone())))),\\n }),\\n value: Box::new(Expr::Ident(ident.clone())),\\n })\\n }\\n }\\n\\n Prop::Assign(..) => unreachable!(\"assign property in object literal is invalid\"),\\n\\n Prop::Getter(..) => prop.visit_mut_children_with(&mut PropNameFolder {\\n props: &mut self.getter_props,\\n }),\\n Prop::Setter(..) => prop.visit_mut_children_with(&mut PropNameFolder {\\n props: &mut self.setter_props,\\n }),\\n _ => {\\n prop.visit_mut_children_with(&mut PropNameFolder {\\n props: &mut self.getter_props,\\n });\\n prop.visit_mut_children_with(&mut PropNameFolder {\\n props: &mut self.setter_props,\\n })\\n }\\n }\\n }\\n}\\n\\nstruct PropNameFolder<\\'a> {\\n props: &\\'a mut FxHashSet,\\n}\\n\\nimpl<\\'a> VisitMut for PropNameFolder<\\'a> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_expr(&mut self, _: &mut Expr) {}\\n\\n fn visit_mut_prop_name(&mut self, name: &mut PropName) {\\n let span = name.span();\\n\\n match name {\\n PropName::Ident(ident) => {\\n if !self.props.insert(ident.sym.clone()) {\\n *name = PropName::Computed(ComputedPropName {\\n span,\\n expr: Box::new(Expr::Lit(Lit::Str(Str {\\n span,\\n value: ident.sym.clone(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n })\\n }\\n }\\n PropName::Str(s) => {\\n if !self.props.insert(s.value.clone()) {\\n *name = PropName::Computed(ComputedPropName {\\n span: s.span,\\n expr: Box::new(Expr::Lit(Lit::Str(s.clone()))),\\n })\\n }\\n }\\n PropName::Computed(ComputedPropName { expr, .. }) => {\\n // Computed property might collide\\n match &**expr {\\n Expr::Lit(Lit::Str(Str { ref value, .. })) => {\\n self.props.insert(value.clone());\\n }\\n _ => {}\\n }\\n }\\n _ => {}\\n }\\n }\\n}\\n',\n", + " 'content_id': 'c4814d713811cb463e89a4225d9ca447acc68d31',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 95,\n", + " 'path': '/ecmascript/transforms/compat/src/es2015/duplicate_keys.rs',\n", + " 'size': 3927,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.49100294985250736,\n", + " 'avg_line_length': 27.016528925619834,\n", + " 'blob_id': '55f28fccd3fa07f23d22e96f428e4207ca3632c9',\n", + " 'content': 'use super::stmt::sort_stmts;\\nuse crate::{dep_graph::ModuleGraph, modules::Modules, ModuleId};\\nuse indexmap::IndexSet;\\nuse petgraph::EdgeDirection::Outgoing;\\nuse rustc_hash::{FxHashSet, FxHasher};\\nuse std::{\\n collections::VecDeque, hash::BuildHasherDefault, iter::from_fn, mem::take, time::Instant,\\n};\\nuse swc_common::{sync::Lrc, SourceMap, SyntaxContext};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::prepend_stmts;\\n\\n/// The unit of sorting.\\n#[derive(Debug)]\\npub(super) struct Chunk {\\n pub stmts: Vec,\\n}\\n\\nimpl Modules {\\n /// Modules with circular import relations will be in same chunk.\\n pub(super) fn take_chunks(\\n &mut self,\\n entry_id: ModuleId,\\n graph: &ModuleGraph,\\n cycle: &Vec>,\\n cm: &Lrc,\\n ) -> Vec {\\n let injected_ctxt = self.injected_ctxt;\\n let mut chunks = vec![];\\n\\n let mut modules = take(&mut self.modules);\\n\\n for (id, module) in &mut modules {\\n if let Some(prepended) = self.prepended_stmts.remove(&*id) {\\n prepend_stmts(&mut module.body, prepended.into_iter());\\n }\\n\\n if let Some(items) = self.appended_stmts.remove(&*id) {\\n module.body.extend(items);\\n }\\n }\\n\\n chunks.extend(toposort_real_modules(\\n injected_ctxt,\\n modules,\\n entry_id,\\n graph,\\n cycle,\\n cm,\\n ));\\n\\n chunks\\n }\\n}\\n\\n/// Sort items topologically, while merging cycles as a\\nfn toposort_real_modules<\\'a>(\\n injected_ctxt: SyntaxContext,\\n mut modules: Vec<(ModuleId, Module)>,\\n entry: ModuleId,\\n graph: &\\'a ModuleGraph,\\n cycles: &\\'a Vec>,\\n cm: &Lrc,\\n) -> Vec {\\n let mut queue = modules.iter().map(|v| v.0).collect::>();\\n queue.push_front(entry);\\n\\n let mut chunks = vec![];\\n\\n tracing::debug!(\\n \"Topologically sorting modules based on the dependency graph: ({} items)\",\\n modules.len()\\n );\\n\\n let start = Instant::now();\\n let sorted_ids = toposort_real_module_ids(queue, graph, &cycles).collect::>();\\n let end = Instant::now();\\n tracing::debug!(\"Toposort of module ids took {:?}\", end - start);\\n for ids in sorted_ids {\\n if ids.is_empty() {\\n continue;\\n }\\n\\n let mut stmts = vec![];\\n\\n for id in ids.iter().copied().rev() {\\n if let Some((_, module)) = modules.iter_mut().find(|(module_id, _)| *module_id == id) {\\n module.body.retain(|item| match item {\\n ModuleItem::Stmt(Stmt::Empty(..)) => false,\\n _ => true,\\n });\\n if module.body.is_empty() {\\n continue;\\n }\\n\\n stmts.push(take(&mut module.body));\\n }\\n }\\n\\n if stmts.is_empty() {\\n continue;\\n }\\n\\n // Skip sorting statements if there is no import.\\n if ids.len() == 1 {\\n if graph.neighbors_directed(ids[0], Outgoing).count() == 0 {\\n chunks.push(Chunk {\\n stmts: stmts.into_iter().next().unwrap(),\\n });\\n continue;\\n }\\n }\\n\\n let stmts = sort_stmts(injected_ctxt, stmts, cm);\\n\\n // print_hygiene(\\n // &format!(\"after sort: {:?}\", ids),\\n // cm,\\n // &Module {\\n // span: DUMMY_SP,\\n // body: stmts.clone(),\\n // shebang: None,\\n // },\\n // );\\n\\n chunks.push(Chunk { stmts })\\n }\\n\\n chunks\\n}\\n\\nfn cycles_for(\\n cycles: &Vec>,\\n id: ModuleId,\\n checked: &mut Vec,\\n) -> IndexSet> {\\n checked.push(id);\\n let mut v = cycles\\n .iter()\\n .filter(|v| v.contains(&id))\\n .flatten()\\n .copied()\\n .collect::>();\\n\\n let ids = v.clone();\\n\\n for added in ids {\\n if checked.contains(&added) {\\n continue;\\n }\\n v.extend(cycles_for(cycles, added, checked));\\n }\\n\\n v\\n}\\n\\nfn toposort_real_module_ids<\\'a>(\\n mut queue: VecDeque,\\n graph: &\\'a ModuleGraph,\\n cycles: &\\'a Vec>,\\n) -> impl \\'a + Iterator> {\\n let mut done = FxHashSet::::default();\\n let mut errored = FxHashSet::::default();\\n\\n from_fn(move || {\\n while let Some(id) = queue.pop_front() {\\n if done.contains(&id) {\\n continue;\\n }\\n\\n // dbg!(id);\\n\\n let deps = graph\\n .neighbors_directed(id, Outgoing)\\n .filter(|dep| !done.contains(&dep))\\n .collect::>();\\n\\n if deps.is_empty() {\\n // TODO: Add dependants\\n\\n // Emit\\n done.insert(id);\\n errored.clear();\\n return Some(vec![id]);\\n }\\n\\n // dbg!(&deps);\\n\\n let mut all_modules_in_circle = cycles_for(cycles, id, &mut Default::default());\\n all_modules_in_circle.reverse();\\n\\n // dbg!(&all_modules_in_circle);\\n\\n if all_modules_in_circle.is_empty() {\\n queue.push_front(id);\\n\\n // This module does not have any circular imports.\\n for dep in deps.iter().copied().rev() {\\n queue.push_front(dep);\\n }\\n\\n continue;\\n }\\n\\n // We need to handle dependencies of all circular modules.\\n let deps_of_circle = all_modules_in_circle\\n .iter()\\n .flat_map(|&id| {\\n graph\\n .neighbors_directed(id, Outgoing)\\n .filter(|dep| !done.contains(&dep) && !all_modules_in_circle.contains(dep))\\n })\\n .collect::>();\\n\\n // dbg!(&deps_of_circle);\\n\\n if !deps_of_circle.is_empty() {\\n if errored.insert(id) {\\n queue.push_front(id);\\n\\n // Handle dependencies first.\\n for dep in deps_of_circle.iter().copied().rev() {\\n queue.push_front(dep);\\n }\\n\\n continue;\\n }\\n tracing::info!(\"Using slow, fallback logic for topological sorting\");\\n all_modules_in_circle.extend(deps_of_circle);\\n }\\n\\n // TODO: Add dependants\\n\\n // Emit\\n done.extend(all_modules_in_circle.iter().copied());\\n errored.clear();\\n return Some(all_modules_in_circle.into_iter().collect());\\n }\\n\\n None\\n })\\n}\\n',\n", + " 'content_id': '98e5e321a1987f59403c4750bed30c6e8f6e9d5f',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/bundler/src/modules/sort/chunk.rs',\n", + " 'size': 6780,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6363636363636364,\n", + " 'avg_line_length': 26.076923076923077,\n", + " 'blob_id': 'bb7f2da44ddb40724ee0c2c484e022830bffa984',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"wasm module for swc\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0 AND MIT\"\\nname = \"wasm\"\\npublish = false\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"1.2.94\"\\n\\n[lib]\\ncrate-type = [\"cdylib\"]\\n\\n[dependencies]\\nanyhow = \"1.0.42\"\\nconsole_error_panic_hook = \"0.1.6\"\\nonce_cell = \"1.3.1\"\\npath-clean = \"0.1\"\\nserde = {version = \"1\", features = [\"derive\"]}\\nserde_json = \"1\"\\nswc = {path = \"../\"}\\nswc_common = {path = \"../common\"}\\nswc_ecmascript = {path = \"../ecmascript\"}\\ntracing = {version = \"0.1.28\", features = [\"release_max_level_off\"]}\\nwasm-bindgen = {version = \"0.2\", features = [\"serde-serialize\"]}\\nwasm-bindgen-futures = \"0.4.8\"\\n',\n", + " 'content_id': 'f1bf3fc9e7683fbd18a621834d0594d6abf769b6',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 68,\n", + " 'path': '/wasm/Cargo.toml',\n", + " 'size': 704,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6762801648028252,\n", + " 'avg_line_length': 36.75555555555555,\n", + " 'blob_id': '9a64c19485c5285c6423d431ca2c53c84800384c',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Ecmascript\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecmascript/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecmascript\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.72.0\"\\n\\n[package.metadata.docs.rs]\\nall-features = true\\n\\n[features]\\ncodegen = [\"swc_ecma_codegen\"]\\ndefault = [\"typescript-parser\"]\\ndep_graph = [\"swc_ecma_dep_graph\"]\\nminifier = [\"swc_ecma_minifier\"]\\nparser = [\"swc_ecma_parser\"]\\npreset_env = [\"swc_ecma_preset_env\"]\\ntransforms = [\"swc_ecma_transforms\"]\\nutils = [\"swc_ecma_utils\"]\\nvisit = [\"swc_ecma_visit\"]\\n\\ntypescript-parser = [\"swc_ecma_parser/typescript\"]\\n\\ncompat = [\"swc_ecma_transforms/compat\"]\\nmodule = [\"swc_ecma_transforms/module\"]\\noptimization = [\"swc_ecma_transforms/optimization\"]\\nproposal = [\"swc_ecma_transforms/proposal\"]\\nreact = [\"swc_ecma_transforms/react\"]\\ntypescript = [\"typescript-parser\", \"swc_ecma_transforms/typescript\"]\\n\\n[dependencies]\\nswc_ecma_ast = {version = \"0.54.0\", path = \"./ast\"}\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"./codegen\", optional = true}\\nswc_ecma_dep_graph = {version = \"0.42.0\", path = \"./dep-graph\", optional = true}\\nswc_ecma_minifier = {version = \"0.36.0\", path = \"./minifier\", optional = true}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"./parser\", optional = true, default-features = false}\\nswc_ecma_preset_env = {version = \"0.51.0\", path = \"./preset-env\", optional = true}\\nswc_ecma_transforms = {version = \"0.80.0\", path = \"./transforms\", optional = true}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"./utils\", optional = true}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"./visit\", optional = true}\\n\\n[dev-dependencies]\\n',\n", + " 'content_id': 'be64b43062ed6990c5714dcb0adb95a23a4d26b5',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/Cargo.toml',\n", + " 'size': 1699,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.41610325752919486,\n", + " 'avg_line_length': 30.37465564738292,\n", + " 'blob_id': '2c49699e8f3c39a68348ec98ed0a307b704e371d',\n", + " 'content': 'pub(crate) use self::entry::Entry;\\nuse self::{\\n builtin::BUILTINS,\\n data::{BUILTIN_TYPES, INSTANCE_PROPERTIES, STATIC_PROPERTIES},\\n};\\nuse crate::{util::DataMapExt, version::should_enable, Versions};\\nuse indexmap::IndexSet;\\nuse rustc_hash::FxHasher;\\nuse std::hash::BuildHasherDefault;\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::DUMMY_SP;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_visit::{noop_visit_type, Node, Visit, VisitWith};\\n\\nmod builtin;\\nmod data;\\nmod entry;\\n\\npub(crate) struct UsageVisitor {\\n is_any_target: bool,\\n target: Versions,\\n pub required: IndexSet<&\\'static str, BuildHasherDefault>,\\n}\\n\\nimpl UsageVisitor {\\n pub fn new(target: Versions) -> Self {\\n // let mut v = Self { required: vec![] };\\n //\\n //\\n // let is_web_target = target\\n // .iter()\\n // .any(|(name, version)| name != \"node\" &&\\n // version.is_some());\\n //\\n // println!(\\n // \"is_any_target={:?}\\\\nis_web_target={:?}\",\\n // is_any_target, is_web_target\\n // );\\n //\\n // // Web default\\n // if is_any_target || is_web_target {\\n // v.add(&[\"web.timers\", \"web.immediate\",\\n // \"web.dom.iterable\"]); }\\n // v\\n\\n let v = Self {\\n is_any_target: target.is_any_target(),\\n target,\\n required: Default::default(),\\n };\\n //if target.is_any_target() || target.node.is_none() {\\n // v.add(&[\"web.timers\", \"web.immediate\", \"web.dom.iterable\"]);\\n //}\\n\\n v\\n }\\n\\n /// Add imports\\n fn add(&mut self, features: &\\'static [&\\'static str]) {\\n let UsageVisitor {\\n is_any_target,\\n target,\\n ..\\n } = self;\\n\\n self.required.extend(features.iter().filter_map(|f| {\\n if !*is_any_target {\\n if let Some(v) = BUILTINS.get(&**f) {\\n // Skip\\n if !should_enable(*target, *v, true) {\\n return None;\\n }\\n }\\n }\\n\\n Some(f)\\n }));\\n }\\n\\n fn add_property_deps_inner(&mut self, obj: Option<&JsWord>, prop: &JsWord) {\\n if let Some(obj) = obj {\\n if let Some(map) = STATIC_PROPERTIES.get_data(&obj) {\\n if let Some(features) = map.get_data(&prop) {\\n self.add(features);\\n }\\n }\\n }\\n\\n if let Some(features) = INSTANCE_PROPERTIES.get_data(&prop) {\\n self.add(features);\\n }\\n }\\n\\n fn visit_object_pat_props(&mut self, obj: &Expr, props: &[ObjectPatProp]) {\\n let obj = match obj {\\n Expr::Ident(i) => Some(&i.sym),\\n _ => None,\\n };\\n\\n for p in props {\\n match p {\\n ObjectPatProp::KeyValue(KeyValuePatProp {\\n key: PropName::Ident(i),\\n ..\\n }) => self.add_property_deps_inner(obj, &i.sym),\\n ObjectPatProp::Assign(AssignPatProp { key, .. }) => {\\n self.add_property_deps_inner(obj, &key.sym)\\n }\\n\\n _ => {}\\n }\\n }\\n }\\n}\\n\\n// TODO:\\n// Program(path: NodePath) {\\n// path.get(\"body\").forEach(bodyPath => {\\n// if (isPolyfillSource(getRequireSource(bodyPath))) {\\n// console.warn(NO_DIRECT_POLYFILL_IMPORT);\\n// bodyPath.remove();\\n// }\\n// });\\n// },\\n\\n/// Detects usage of types\\nimpl Visit for UsageVisitor {\\n noop_visit_type!();\\n\\n fn visit_ident(&mut self, node: &Ident, _: &dyn Node) {\\n node.visit_children_with(self);\\n\\n for (name, builtin) in BUILTIN_TYPES {\\n if node.sym == **name {\\n self.add(builtin)\\n }\\n }\\n }\\n\\n fn visit_var_declarator(&mut self, d: &VarDeclarator, _: &dyn Node) {\\n d.visit_children_with(self);\\n\\n if let Some(ref init) = d.init {\\n match d.name {\\n // const { keys, values } = Object\\n Pat::Object(ref o) => self.visit_object_pat_props(&init, &o.props),\\n _ => {}\\n }\\n } else {\\n match d.name {\\n // const { keys, values } = Object\\n Pat::Object(ref o) => self.visit_object_pat_props(\\n &Expr::Ident(Ident::new(js_word!(\"\"), DUMMY_SP)),\\n &o.props,\\n ),\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_assign_expr(&mut self, e: &AssignExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match &e.left {\\n // ({ keys, values } = Object)\\n PatOrExpr::Pat(pat) => match &**pat {\\n Pat::Object(ref o) => self.visit_object_pat_props(&e.right, &o.props),\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n /// Detects usage of instance properties and static properties.\\n ///\\n /// - `Array.from`\\n fn visit_member_expr(&mut self, node: &MemberExpr, _: &dyn Node) {\\n node.obj.visit_with(node as _, self);\\n if node.computed {\\n node.prop.visit_with(node as _, self);\\n }\\n //enter(path: NodePath) {\\n // const { node } = path;\\n // const { object, property } = node;\\n //\\n // // ignore namespace\\n // if (isNamespaced(path.get(\"object\"))) return;\\n //\\n // let evaluatedPropType = object.name;\\n // let propertyName = \"\";\\n // let instanceType = \"\";\\n //\\n // if (node.computed) {\\n // if (t.isStringLiteral(property)) {\\n // propertyName = property.value;\\n // } else {\\n // const result = path.get(\"property\").evaluate();\\n // if (result.confident && result.value) {\\n // propertyName = result.value;\\n // }\\n // }\\n // } else {\\n // propertyName = property.name;\\n // }\\n //\\n // if (path.scope.getBindingIdentifier(object.name)) {\\n // const result = path.get(\"object\").evaluate();\\n // if (result.value) {\\n // instanceType = getType(result.value);\\n // } else if (result.deopt && result.deopt.isIdentifier()) {\\n // evaluatedPropType = result.deopt.node.name;\\n // }\\n // }\\n //\\n // if (has(STATIC_PROPERTIES, evaluatedPropType)) {\\n // const BuiltInProperties = STATIC_PROPERTIES[evaluatedPropType];\\n // if (has(BuiltInProperties, propertyName)) {\\n // const StaticPropertyDependencies =\\n // BuiltInProperties[propertyName];\\n // this.addUnsupported(StaticPropertyDependencies); }\\n // }\\n //\\n // if (has(INSTANCE_PROPERTIES, propertyName)) {\\n // let InstancePropertyDependencies = INSTANCE_PROPERTIES[propertyName];\\n // if (instanceType) {\\n // InstancePropertyDependencies =\\n // InstancePropertyDependencies.filter( module =>\\n // module.includes(instanceType), );\\n // }\\n // this.addUnsupported(InstancePropertyDependencies);\\n // }\\n //},\\n //\\n //// Symbol.match\\n //exit(path: NodePath) {\\n // const { name } = path.node.object;\\n //\\n // if (!has(BUILT_INS, name)) return;\\n // if (path.scope.getBindingIdentifier(name)) return;\\n //\\n // const BuiltInDependencies = BUILT_INS[name];\\n // this.addUnsupported(BuiltInDependencies);\\n //},\\n\\n match *node.prop {\\n Expr::Ident(ref i) if !node.computed => {\\n //\\n for (name, imports) in INSTANCE_PROPERTIES {\\n if i.sym == **name {\\n self.add(imports)\\n }\\n }\\n }\\n Expr::Lit(Lit::Str(Str { ref value, .. })) if node.computed => {\\n for (name, imports) in INSTANCE_PROPERTIES {\\n if *value == **name {\\n self.add(imports);\\n }\\n }\\n }\\n _ => {}\\n }\\n\\n match node.obj {\\n ExprOrSuper::Expr(ref e) => match &**e {\\n Expr::Ident(obj) => {\\n for (ty, props) in STATIC_PROPERTIES {\\n if obj.sym == **ty {\\n match *node.prop {\\n Expr::Lit(Lit::Str(Str { ref value, .. })) if node.computed => {\\n for (name, imports) in INSTANCE_PROPERTIES {\\n if *value == **name {\\n self.add(imports);\\n }\\n }\\n }\\n\\n Expr::Ident(ref p) if !node.computed => {\\n for (prop, imports) in *props {\\n if p.sym == **prop {\\n self.add(imports);\\n }\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n }\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n ///\\n /// - `arr[Symbol.iterator]()`\\n fn visit_call_expr(&mut self, e: &CallExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n if match &e.callee {\\n ExprOrSuper::Expr(callee) => match &**callee {\\n Expr::Member(MemberExpr {\\n computed: true,\\n prop,\\n ..\\n }) if is_symbol_iterator(&prop) => true,\\n _ => false,\\n },\\n _ => false,\\n } {\\n self.add(&[\"web.dom.iterable\"])\\n }\\n }\\n\\n ///\\n /// - `Symbol.iterator in arr`\\n\\n fn visit_bin_expr(&mut self, e: &BinExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match e.op {\\n op!(\"in\") if is_symbol_iterator(&e.left) => self.add(&[\"web.dom.iterable\"]),\\n _ => {}\\n }\\n }\\n\\n ///\\n /// - `yield*`\\n fn visit_yield_expr(&mut self, e: &YieldExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n println!(\"Yield\");\\n\\n if e.delegate {\\n self.add(&[\"web.dom.iterable\"])\\n }\\n }\\n}\\n\\nfn is_symbol_iterator(e: &Expr) -> bool {\\n match e {\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n prop,\\n computed: false,\\n ..\\n }) => match &**obj {\\n Expr::Ident(Ident {\\n sym: js_word!(\"Symbol\"),\\n ..\\n }) => match &**prop {\\n Expr::Ident(Ident {\\n sym: js_word!(\"iterator\"),\\n ..\\n }) => true,\\n _ => false,\\n },\\n _ => false,\\n },\\n _ => false,\\n }\\n}\\n',\n", + " 'content_id': '119ccaeb6bf172a4bc46272f6a742a26ce818b93',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/preset-env/src/corejs2/mod.rs',\n", + " 'size': 11389,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3936352509179927,\n", + " 'avg_line_length': 29.714285714285715,\n", + " 'blob_id': 'ce12b6415575481891c605bbd6ebbee27ecd2eef',\n", + " 'content': 'use super::builtin::BUILTINS;\\nuse crate::{version::should_enable, Versions};\\nuse indexmap::IndexSet;\\nuse rustc_hash::FxHasher;\\nuse std::hash::BuildHasherDefault;\\nuse swc_atoms::js_word;\\nuse swc_common::{util::move_map::MoveMap, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_visit::{Fold, FoldWith};\\n\\n#[derive(Debug)]\\npub struct Entry {\\n is_any_target: bool,\\n target: Versions,\\n pub imports: IndexSet<&\\'static str, BuildHasherDefault>,\\n}\\n\\nimpl Entry {\\n pub fn new(target: Versions, regenerator: bool) -> Self {\\n let is_any_target = target.is_any_target();\\n let is_web_target = target.iter().any(|(k, v)| {\\n if k == \"node\" {\\n return false;\\n }\\n\\n v.is_some()\\n });\\n\\n let mut v = Entry {\\n is_any_target: target.is_any_target(),\\n target,\\n imports: Default::default(),\\n };\\n if is_any_target || is_web_target {\\n v.imports.insert(\"web.timers\".into());\\n v.imports.insert(\"web.immediate\".into());\\n v.imports.insert(\"web.dom.iterable\".into());\\n }\\n\\n if regenerator {\\n v.imports.insert(\"regenerator-runtime/runtime\".into());\\n }\\n\\n v\\n }\\n\\n /// Add imports.\\n /// Returns true if it\\'s replaced.\\n fn add_all(&mut self, src: &str) -> bool {\\n if src != \"@babel/polyfill\" && src != \"@swc/polyfill\" && src != \"core-js\" {\\n return false;\\n }\\n\\n for (feature, version) in BUILTINS.iter() {\\n self.add_inner(&feature, *version);\\n }\\n\\n true\\n }\\n\\n fn add_inner(&mut self, feature: &\\'static str, version: Versions) {\\n if self.is_any_target || should_enable(self.target, version, true) {\\n self.imports.insert(feature);\\n }\\n }\\n}\\n\\nimpl Fold for Entry {\\n fn fold_import_decl(&mut self, i: ImportDecl) -> ImportDecl {\\n let i: ImportDecl = i.fold_children_with(self);\\n\\n let remove = i.specifiers.is_empty() && self.add_all(&i.src.value);\\n\\n if remove {\\n ImportDecl {\\n src: Str {\\n span: DUMMY_SP,\\n value: js_word!(\"\"),\\n ..i.src\\n },\\n ..i\\n }\\n } else {\\n i\\n }\\n }\\n\\n fn fold_module_items(&mut self, items: Vec) -> Vec {\\n items.move_flat_map(|item| {\\n let item: ModuleItem = item.fold_with(self);\\n\\n match &item {\\n ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) => match &**expr {\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(callee),\\n ref args,\\n ..\\n }) => match &**callee {\\n Expr::Ident(Ident {\\n sym: js_word!(\"require\"),\\n ..\\n }) => {\\n if args.len() == 1\\n && match &args[0] {\\n ExprOrSpread { spread: None, expr } => match &**expr {\\n Expr::Lit(Lit::Str(s)) => {\\n s.value == *\"core-js\"\\n || s.value == *\"@swc/polyfill\"\\n || s.value == *\"@babel/polyfill\"\\n }\\n _ => false,\\n },\\n _ => false,\\n }\\n {\\n if self.add_all(\"@swc/polyfill\") {\\n return None;\\n }\\n }\\n }\\n\\n _ => {}\\n },\\n _ => {}\\n },\\n\\n _ => {}\\n }\\n\\n Some(item)\\n })\\n }\\n}\\n',\n", + " 'content_id': '25393e9e07733de080db6addbb3154ccdec340ad',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 90,\n", + " 'path': '/ecmascript/preset-env/src/corejs2/entry.rs',\n", + " 'size': 4085,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5246027574495613,\n", + " 'avg_line_length': 26.915349887133182,\n", + " 'blob_id': 'b8b1feb20b985f28ad5f18c37eca07977fdc41e9',\n", + " 'content': '//! `GraphMap` is a graph datastructure where node values are mapping\\n//! keys.\\n\\n#![allow(dead_code)] // We don\\'t want to modify copied source code.\\n\\nuse indexmap::{\\n map::{Iter as IndexMapIter, IterMut as IndexMapIterMut, Keys},\\n IndexMap,\\n};\\nuse petgraph::{\\n graph::{node_index, Graph},\\n visit::{GraphBase, IntoNeighbors, IntoNeighborsDirected, NodeCount, Visitable},\\n Directed, Direction, EdgeType, Incoming, IntoWeightedEdge, Outgoing, Undirected,\\n};\\nuse rustc_hash::{FxHashSet, FxHasher};\\nuse std::{\\n cmp::Ordering,\\n fmt,\\n hash::{self, BuildHasherDefault, Hash},\\n iter::{Cloned, DoubleEndedIterator, FromIterator},\\n marker::PhantomData,\\n ops::Deref,\\n slice::Iter,\\n};\\n\\n/// A `GraphMap` with directed edges.\\n///\\n/// For example, an edge from *1* to *2* is distinct from an edge from *2* to\\n/// *1*.\\npub type FastDiGraphMap = FastGraphMap;\\n\\n/// `GraphMap` is a graph datastructure using an associative array\\n/// of its node weights `N`.\\n///\\n/// It uses an combined adjacency list and sparse adjacency matrix\\n/// representation, using **O(|V| + |E|)** space, and allows testing for edge\\n/// existence in constant time.\\n///\\n/// `GraphMap` is parameterized over:\\n///\\n/// - Associated data `N` for nodes and `E` for edges, called *weights*.\\n/// - The node weight `N` must implement `Copy` and will be used as node\\n/// identifier, duplicated into several places in the data structure.\\n/// It must be suitable as a hash table key (implementing `Eq + Hash`).\\n/// The node type must also implement `Ord` so that the implementation can\\n/// order the pair (`a`, `b`) for an edge connecting any two nodes `a` and `b`.\\n/// - `E` can be of arbitrary type.\\n/// - Edge type `Ty` that determines whether the graph edges are directed or\\n/// undirected.\\n///\\n/// You can use the type aliases `UnGraphMap` and `DiGraphMap` for convenience.\\n///\\n/// `GraphMap` does not allow parallel edges, but self loops are allowed.\\n///\\n/// Depends on crate feature `graphmap` (default).\\n#[derive(Clone)]\\npub struct FastGraphMap {\\n nodes: IndexMap, BuildHasherDefault>,\\n edges: IndexMap<(N, N), E, BuildHasherDefault>,\\n ty: PhantomData,\\n}\\n\\nimpl fmt::Debug for FastGraphMap {\\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\\n self.nodes.fmt(f)\\n }\\n}\\n\\n/// A trait group for `GraphMap`\\'s node identifier.\\npub trait NodeTrait: Copy + Ord + Hash {}\\nimpl NodeTrait for N where N: Copy + Ord + Hash {}\\n\\n// non-repr(usize) version of Direction\\n#[derive(Copy, Clone, Debug, PartialEq)]\\nenum CompactDirection {\\n Outgoing,\\n Incoming,\\n}\\n\\nimpl From for CompactDirection {\\n fn from(d: Direction) -> Self {\\n match d {\\n Outgoing => CompactDirection::Outgoing,\\n Incoming => CompactDirection::Incoming,\\n }\\n }\\n}\\n\\nimpl PartialEq for CompactDirection {\\n fn eq(&self, rhs: &Direction) -> bool {\\n (*self as usize) == (*rhs as usize)\\n }\\n}\\n\\nimpl FastGraphMap\\nwhere\\n N: NodeTrait,\\n Ty: EdgeType,\\n{\\n /// Create a new `GraphMap`\\n pub fn new() -> Self {\\n Self::default()\\n }\\n\\n /// Create a new `GraphMap` with estimated capacity.\\n pub fn with_capacity(nodes: usize, edges: usize) -> Self {\\n FastGraphMap {\\n nodes: IndexMap::with_capacity_and_hasher(nodes, Default::default()),\\n edges: IndexMap::with_capacity_and_hasher(edges, Default::default()),\\n ty: PhantomData,\\n }\\n }\\n\\n /// Return the current node and edge capacity of the graph.\\n pub fn capacity(&self) -> (usize, usize) {\\n (self.nodes.capacity(), self.edges.capacity())\\n }\\n\\n /// Use their natural order to map the node pair (a, b) to a canonical edge\\n /// id.\\n #[inline]\\n fn edge_key(a: N, b: N) -> (N, N) {\\n if Ty::is_directed() || a <= b {\\n (a, b)\\n } else {\\n (b, a)\\n }\\n }\\n\\n /// Whether the graph has directed edges.\\n pub fn is_directed(&self) -> bool {\\n Ty::is_directed()\\n }\\n\\n /// Create a new `GraphMap` from an iterable of edges.\\n ///\\n /// Node values are taken directly from the list.\\n /// Edge weights `E` may either be specified in the list,\\n /// or they are filled with default values.\\n ///\\n /// Nodes are inserted automatically to match the edges.\\n ///\\n /// ```\\n /// use petgraph::graphmap::UnGraphMap;\\n ///\\n /// // Create a new undirected GraphMap.\\n /// // Use a type hint to have `()` be the edge weight type.\\n /// let gr = UnGraphMap::<_, ()>::from_edges(&[\\n /// (0, 1), (0, 2), (0, 3),\\n /// (1, 2), (1, 3),\\n /// (2, 3),\\n /// ]);\\n /// ```\\n pub fn from_edges(iterable: I) -> Self\\n where\\n I: IntoIterator,\\n I::Item: IntoWeightedEdge,\\n {\\n Self::from_iter(iterable)\\n }\\n\\n /// Return the number of nodes in the graph.\\n pub fn node_count(&self) -> usize {\\n self.nodes.len()\\n }\\n\\n /// Return the number of edges in the graph.\\n pub fn edge_count(&self) -> usize {\\n self.edges.len()\\n }\\n\\n /// Remove all nodes and edges\\n pub fn clear(&mut self) {\\n self.nodes.clear();\\n self.edges.clear();\\n }\\n\\n /// Add node `n` to the graph.\\n pub fn add_node(&mut self, n: N) -> N {\\n self.nodes.entry(n).or_insert(Vec::new());\\n n\\n }\\n\\n /// Return `true` if node `n` was removed.\\n ///\\n /// Computes in **O(V)** time, due to the removal of edges with other nodes.\\n pub fn remove_node(&mut self, n: N) -> bool {\\n let links = match self.nodes.swap_remove(&n) {\\n None => return false,\\n Some(sus) => sus,\\n };\\n for (succ, _) in links {\\n // remove all successor links\\n self.remove_single_edge(&succ, &n, Incoming);\\n // Remove all edge values\\n self.edges.swap_remove(&Self::edge_key(n, succ));\\n }\\n true\\n }\\n\\n /// Return `true` if the node is contained in the graph.\\n pub fn contains_node(&self, n: N) -> bool {\\n self.nodes.contains_key(&n)\\n }\\n\\n /// Add an edge connecting `a` and `b` to the graph, with associated\\n /// data `weight`. For a directed graph, the edge is directed from `a`\\n /// to `b`.\\n ///\\n /// Inserts nodes `a` and/or `b` if they aren\\'t already part of the graph.\\n ///\\n /// Return `None` if the edge did not previously exist, otherwise,\\n /// the associated data is updated and the old value is returned\\n /// as `Some(old_weight)`.\\n ///\\n /// ```\\n /// // Create a GraphMap with directed edges, and add one edge to it\\n /// use petgraph::graphmap::DiGraphMap;\\n ///\\n /// let mut g = DiGraphMap::new();\\n /// g.add_edge(\"x\", \"y\", -1);\\n /// assert_eq!(g.node_count(), 2);\\n /// assert_eq!(g.edge_count(), 1);\\n /// assert!(g.contains_edge(\"x\", \"y\"));\\n /// assert!(!g.contains_edge(\"y\", \"x\"));\\n /// ```\\n pub fn add_edge(&mut self, a: N, b: N, weight: E) -> Option {\\n if let old @ Some(_) = self.edges.insert(Self::edge_key(a, b), weight) {\\n old\\n } else {\\n // insert in the adjacency list if it\\'s a new edge\\n self.nodes\\n .entry(a)\\n .or_insert_with(|| Vec::with_capacity(1))\\n .push((b, CompactDirection::Outgoing));\\n if a != b {\\n // self loops don\\'t have the Incoming entry\\n self.nodes\\n .entry(b)\\n .or_insert_with(|| Vec::with_capacity(1))\\n .push((a, CompactDirection::Incoming));\\n }\\n None\\n }\\n }\\n\\n /// Remove edge relation from a to b\\n ///\\n /// Return `true` if it did exist.\\n fn remove_single_edge(&mut self, a: &N, b: &N, dir: Direction) -> bool {\\n match self.nodes.get_mut(a) {\\n None => false,\\n Some(sus) => {\\n if Ty::is_directed() {\\n match sus\\n .iter()\\n .position(|elt| elt == &(*b, CompactDirection::from(dir)))\\n {\\n Some(index) => {\\n sus.swap_remove(index);\\n true\\n }\\n None => false,\\n }\\n } else {\\n match sus.iter().position(|elt| &elt.0 == b) {\\n Some(index) => {\\n sus.swap_remove(index);\\n true\\n }\\n None => false,\\n }\\n }\\n }\\n }\\n }\\n\\n /// Remove edge from `a` to `b` from the graph and return the edge weight.\\n ///\\n /// Return `None` if the edge didn\\'t exist.\\n ///\\n /// ```\\n /// // Create a GraphMap with undirected edges, and add and remove an edge.\\n /// use petgraph::graphmap::UnGraphMap;\\n ///\\n /// let mut g = UnGraphMap::new();\\n /// g.add_edge(\"x\", \"y\", -1);\\n ///\\n /// let edge_data = g.remove_edge(\"y\", \"x\");\\n /// assert_eq!(edge_data, Some(-1));\\n /// assert_eq!(g.edge_count(), 0);\\n /// ```\\n pub fn remove_edge(&mut self, a: N, b: N) -> Option {\\n let exist1 = self.remove_single_edge(&a, &b, Outgoing);\\n let exist2 = if a != b {\\n self.remove_single_edge(&b, &a, Incoming)\\n } else {\\n exist1\\n };\\n let weight = self.edges.remove(&Self::edge_key(a, b));\\n debug_assert!(exist1 == exist2 && exist1 == weight.is_some());\\n weight\\n }\\n\\n /// Return `true` if the edge connecting `a` with `b` is contained in the\\n /// graph.\\n pub fn contains_edge(&self, a: N, b: N) -> bool {\\n self.edges.contains_key(&Self::edge_key(a, b))\\n }\\n\\n /// Return an iterator over the nodes of the graph.\\n ///\\n /// Iterator element type is `N`.\\n pub fn nodes(&self) -> Nodes {\\n Nodes {\\n iter: self.nodes.keys().cloned(),\\n }\\n }\\n\\n /// Return an iterator of all nodes with an edge starting from `a`.\\n ///\\n /// - `Directed`: Outgoing edges from `a`.\\n /// - `Undirected`: All edges from or to `a`.\\n ///\\n /// Produces an empty iterator if the node doesn\\'t exist.
\\n /// Iterator element type is `N`.\\n pub fn neighbors(&self, a: N) -> Neighbors {\\n Neighbors {\\n iter: match self.nodes.get(&a) {\\n Some(neigh) => neigh.iter(),\\n None => [].iter(),\\n },\\n ty: self.ty,\\n }\\n }\\n\\n /// Return an iterator of all neighbors that have an edge between them and\\n /// `a`, in the specified direction.\\n /// If the graph\\'s edges are undirected, this is equivalent to\\n /// *.neighbors(a)*.\\n ///\\n /// - `Directed`, `Outgoing`: All edges from `a`.\\n /// - `Directed`, `Incoming`: All edges to `a`.\\n /// - `Undirected`: All edges from or to `a`.\\n ///\\n /// Produces an empty iterator if the node doesn\\'t exist.
\\n /// Iterator element type is `N`.\\n pub fn neighbors_directed(&self, a: N, dir: Direction) -> NeighborsDirected {\\n NeighborsDirected {\\n iter: match self.nodes.get(&a) {\\n Some(neigh) => neigh.iter(),\\n None => [].iter(),\\n },\\n start_node: a,\\n dir,\\n ty: self.ty,\\n }\\n }\\n\\n /// Return an iterator of target nodes with an edge starting from `a`,\\n /// paired with their respective edge weights.\\n ///\\n /// - `Directed`: Outgoing edges from `a`.\\n /// - `Undirected`: All edges from or to `a`.\\n ///\\n /// Produces an empty iterator if the node doesn\\'t exist.
\\n /// Iterator element type is `(N, &E)`.\\n pub fn edges(&self, from: N) -> Edges {\\n Edges {\\n from,\\n iter: self.neighbors(from),\\n edges: &self.edges,\\n }\\n }\\n\\n /// Return a reference to the edge weight connecting `a` with `b`, or\\n /// `None` if the edge does not exist in the graph.\\n pub fn edge_weight(&self, a: N, b: N) -> Option<&E> {\\n self.edges.get(&Self::edge_key(a, b))\\n }\\n\\n /// Return a mutable reference to the edge weight connecting `a` with `b`,\\n /// or `None` if the edge does not exist in the graph.\\n pub fn edge_weight_mut(&mut self, a: N, b: N) -> Option<&mut E> {\\n self.edges.get_mut(&Self::edge_key(a, b))\\n }\\n\\n /// Return an iterator over all edges of the graph with their weight in\\n /// arbitrary order.\\n ///\\n /// Iterator element type is `(N, N, &E)`\\n pub fn all_edges(&self) -> AllEdges {\\n AllEdges {\\n inner: self.edges.iter(),\\n ty: self.ty,\\n }\\n }\\n\\n /// Return an iterator over all edges of the graph in arbitrary order, with\\n /// a mutable reference to their weight.\\n ///\\n /// Iterator element type is `(N, N, &mut E)`\\n pub fn all_edges_mut(&mut self) -> AllEdgesMut {\\n AllEdgesMut {\\n inner: self.edges.iter_mut(),\\n ty: self.ty,\\n }\\n }\\n\\n /// Return a `Graph` that corresponds to this `GraphMap`.\\n ///\\n /// 1. Note that node and edge indices in the `Graph` have nothing in common\\n /// with the `GraphMap`s node weights `N`. The node weights `N` are used\\n /// as node weights in the resulting `Graph`, too.\\n /// 2. Note that the index type is user-chosen.\\n ///\\n /// Computes in **O(|V| + |E|)** time (average).\\n ///\\n /// **Panics** if the number of nodes or edges does not fit with\\n /// the resulting graph\\'s index type.\\n pub fn into_graph(self) -> Graph\\n where\\n Ix: petgraph::graph::IndexType,\\n {\\n // assuming two successive iterations of the same hashmap produce the same order\\n let mut gr = Graph::with_capacity(self.node_count(), self.edge_count());\\n for (&node, _) in &self.nodes {\\n gr.add_node(node);\\n }\\n for ((a, b), edge_weight) in self.edges {\\n let (ai, _, _) = self.nodes.get_full(&a).unwrap();\\n let (bi, _, _) = self.nodes.get_full(&b).unwrap();\\n gr.add_edge(node_index(ai), node_index(bi), edge_weight);\\n }\\n gr\\n }\\n}\\n\\n/// Create a new `GraphMap` from an iterable of edges.\\nimpl FromIterator for FastGraphMap\\nwhere\\n Item: IntoWeightedEdge,\\n N: NodeTrait,\\n Ty: EdgeType,\\n{\\n fn from_iter(iterable: I) -> Self\\n where\\n I: IntoIterator,\\n {\\n let iter = iterable.into_iter();\\n let (low, _) = iter.size_hint();\\n let mut g = Self::with_capacity(0, low);\\n g.extend(iter);\\n g\\n }\\n}\\n\\n/// Extend the graph from an iterable of edges.\\n///\\n/// Nodes are inserted automatically to match the edges.\\nimpl Extend for FastGraphMap\\nwhere\\n Item: IntoWeightedEdge,\\n N: NodeTrait,\\n Ty: EdgeType,\\n{\\n fn extend(&mut self, iterable: I)\\n where\\n I: IntoIterator,\\n {\\n let iter = iterable.into_iter();\\n let (low, _) = iter.size_hint();\\n self.edges.reserve(low);\\n\\n for elt in iter {\\n let (source, target, weight) = elt.into_weighted_edge();\\n self.add_edge(source, target, weight);\\n }\\n }\\n}\\n\\nmacro_rules! iterator_wrap {\\n ($name: ident <$($typarm:tt),*> where { $($bounds: tt)* }\\n item: $item: ty,\\n iter: $iter: ty,\\n ) => (\\n pub struct $name <$($typarm),*> where $($bounds)* {\\n iter: $iter,\\n }\\n impl<$($typarm),*> Iterator for $name <$($typarm),*>\\n where $($bounds)*\\n {\\n type Item = $item;\\n #[inline]\\n fn next(&mut self) -> Option {\\n self.iter.next()\\n }\\n\\n #[inline]\\n fn size_hint(&self) -> (usize, Option) {\\n self.iter.size_hint()\\n }\\n }\\n );\\n}\\n\\niterator_wrap! {\\n Nodes <\\'a, N> where { N: \\'a + NodeTrait }\\n item: N,\\n iter: Cloned>>,\\n}\\n\\npub struct Neighbors<\\'a, N, Ty = Undirected>\\nwhere\\n N: \\'a,\\n Ty: EdgeType,\\n{\\n iter: Iter<\\'a, (N, CompactDirection)>,\\n ty: PhantomData,\\n}\\n\\nimpl<\\'a, N, Ty> Iterator for Neighbors<\\'a, N, Ty>\\nwhere\\n N: NodeTrait,\\n Ty: EdgeType,\\n{\\n type Item = N;\\n fn next(&mut self) -> Option {\\n if Ty::is_directed() {\\n (&mut self.iter)\\n .filter_map(|&(n, dir)| if dir == Outgoing { Some(n) } else { None })\\n .next()\\n } else {\\n self.iter.next().map(|&(n, _)| n)\\n }\\n }\\n}\\n\\npub struct NeighborsDirected<\\'a, N, Ty>\\nwhere\\n N: \\'a,\\n Ty: EdgeType,\\n{\\n iter: Iter<\\'a, (N, CompactDirection)>,\\n start_node: N,\\n dir: Direction,\\n ty: PhantomData,\\n}\\n\\nimpl<\\'a, N, Ty> Iterator for NeighborsDirected<\\'a, N, Ty>\\nwhere\\n N: NodeTrait,\\n Ty: EdgeType,\\n{\\n type Item = N;\\n fn next(&mut self) -> Option {\\n if Ty::is_directed() {\\n let self_dir = self.dir;\\n let start_node = self.start_node;\\n (&mut self.iter)\\n .filter_map(move |&(n, dir)| {\\n if dir == self_dir || n == start_node {\\n Some(n)\\n } else {\\n None\\n }\\n })\\n .next()\\n } else {\\n self.iter.next().map(|&(n, _)| n)\\n }\\n }\\n}\\n\\npub struct Edges<\\'a, N, E: \\'a, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n Ty: EdgeType,\\n{\\n from: N,\\n edges: &\\'a IndexMap<(N, N), E, BuildHasherDefault>,\\n iter: Neighbors<\\'a, N, Ty>,\\n}\\n\\nimpl<\\'a, N, E, Ty> Iterator for Edges<\\'a, N, E, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n E: \\'a,\\n Ty: EdgeType,\\n{\\n type Item = (N, N, &\\'a E);\\n fn next(&mut self) -> Option {\\n match self.iter.next() {\\n None => None,\\n Some(b) => {\\n let a = self.from;\\n match self.edges.get(&FastGraphMap::::edge_key(a, b)) {\\n None => unreachable!(),\\n Some(edge) => Some((a, b, edge)),\\n }\\n }\\n }\\n }\\n}\\n\\npub struct AllEdges<\\'a, N, E: \\'a, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n{\\n inner: IndexMapIter<\\'a, (N, N), E>,\\n ty: PhantomData,\\n}\\n\\nimpl<\\'a, N, E, Ty> Iterator for AllEdges<\\'a, N, E, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n E: \\'a,\\n Ty: EdgeType,\\n{\\n type Item = (N, N, &\\'a E);\\n fn next(&mut self) -> Option {\\n match self.inner.next() {\\n None => None,\\n Some((&(a, b), v)) => Some((a, b, v)),\\n }\\n }\\n\\n fn size_hint(&self) -> (usize, Option) {\\n self.inner.size_hint()\\n }\\n\\n fn count(self) -> usize {\\n self.inner.count()\\n }\\n\\n fn nth(&mut self, n: usize) -> Option {\\n self.inner\\n .nth(n)\\n .map(|(&(n1, n2), weight)| (n1, n2, weight))\\n }\\n\\n fn last(self) -> Option {\\n self.inner\\n .last()\\n .map(|(&(n1, n2), weight)| (n1, n2, weight))\\n }\\n}\\n\\nimpl<\\'a, N, E, Ty> DoubleEndedIterator for AllEdges<\\'a, N, E, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n E: \\'a,\\n Ty: EdgeType,\\n{\\n fn next_back(&mut self) -> Option {\\n self.inner\\n .next_back()\\n .map(|(&(n1, n2), weight)| (n1, n2, weight))\\n }\\n}\\n\\npub struct AllEdgesMut<\\'a, N, E: \\'a, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n{\\n inner: IndexMapIterMut<\\'a, (N, N), E>,\\n ty: PhantomData,\\n}\\n\\nimpl<\\'a, N, E, Ty> Iterator for AllEdgesMut<\\'a, N, E, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n E: \\'a,\\n Ty: EdgeType,\\n{\\n type Item = (N, N, &\\'a mut E);\\n fn next(&mut self) -> Option {\\n self.inner\\n .next()\\n .map(|(&(n1, n2), weight)| (n1, n2, weight))\\n }\\n\\n fn size_hint(&self) -> (usize, Option) {\\n self.inner.size_hint()\\n }\\n\\n fn count(self) -> usize {\\n self.inner.count()\\n }\\n\\n fn nth(&mut self, n: usize) -> Option {\\n self.inner\\n .nth(n)\\n .map(|(&(n1, n2), weight)| (n1, n2, weight))\\n }\\n\\n fn last(self) -> Option {\\n self.inner\\n .last()\\n .map(|(&(n1, n2), weight)| (n1, n2, weight))\\n }\\n}\\n\\nimpl<\\'a, N, E, Ty> DoubleEndedIterator for AllEdgesMut<\\'a, N, E, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n E: \\'a,\\n Ty: EdgeType,\\n{\\n fn next_back(&mut self) -> Option {\\n self.inner\\n .next_back()\\n .map(|(&(n1, n2), weight)| (n1, n2, weight))\\n }\\n}\\n\\n/// Create a new empty `GraphMap`.\\nimpl Default for FastGraphMap\\nwhere\\n N: NodeTrait,\\n Ty: EdgeType,\\n{\\n fn default() -> Self {\\n FastGraphMap::with_capacity(0, 0)\\n }\\n}\\n\\n/// A reference that is hashed and compared by its pointer value.\\n///\\n/// `Ptr` is used for certain configurations of `GraphMap`,\\n/// in particular in the combination where the node type for\\n/// `GraphMap` is something of type for example `Ptr(&Cell)`,\\n/// with the `Cell` being `TypedArena` allocated.\\npub struct Ptr<\\'b, T: \\'b>(pub &\\'b T);\\n\\nimpl<\\'b, T> Copy for Ptr<\\'b, T> {}\\nimpl<\\'b, T> Clone for Ptr<\\'b, T> {\\n fn clone(&self) -> Self {\\n *self\\n }\\n}\\n\\nfn ptr_eq(a: *const T, b: *const T) -> bool {\\n a == b\\n}\\n\\nimpl<\\'b, T> PartialEq for Ptr<\\'b, T> {\\n /// Ptr compares by pointer equality, i.e if they point to the same value\\n fn eq(&self, other: &Ptr<\\'b, T>) -> bool {\\n ptr_eq(self.0, other.0)\\n }\\n}\\n\\nimpl<\\'b, T> PartialOrd for Ptr<\\'b, T> {\\n fn partial_cmp(&self, other: &Ptr<\\'b, T>) -> Option {\\n Some(self.cmp(other))\\n }\\n}\\n\\nimpl<\\'b, T> Ord for Ptr<\\'b, T> {\\n /// Ptr is ordered by pointer value, i.e. an arbitrary but stable and total\\n /// order.\\n fn cmp(&self, other: &Ptr<\\'b, T>) -> Ordering {\\n let a: *const T = self.0;\\n let b: *const T = other.0;\\n a.cmp(&b)\\n }\\n}\\n\\nimpl<\\'b, T> Deref for Ptr<\\'b, T> {\\n type Target = T;\\n fn deref(&self) -> &T {\\n self.0\\n }\\n}\\n\\nimpl<\\'b, T> Eq for Ptr<\\'b, T> {}\\n\\nimpl<\\'b, T> Hash for Ptr<\\'b, T> {\\n fn hash(&self, st: &mut H) {\\n let ptr = (self.0) as *const T;\\n ptr.hash(st)\\n }\\n}\\n\\nimpl<\\'b, T: fmt::Debug> fmt::Debug for Ptr<\\'b, T> {\\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\\n self.0.fmt(f)\\n }\\n}\\n\\npub struct NodeIdentifiers<\\'a, N, E: \\'a, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n{\\n iter: IndexMapIter<\\'a, N, Vec<(N, CompactDirection)>>,\\n ty: PhantomData,\\n edge_ty: PhantomData,\\n}\\n\\nimpl<\\'a, N, E, Ty> Iterator for NodeIdentifiers<\\'a, N, E, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n E: \\'a,\\n Ty: EdgeType,\\n{\\n type Item = N;\\n fn next(&mut self) -> Option {\\n self.iter.next().map(|(&n, _)| n)\\n }\\n}\\n\\npub struct NodeReferences<\\'a, N, E: \\'a, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n{\\n iter: IndexMapIter<\\'a, N, Vec<(N, CompactDirection)>>,\\n ty: PhantomData,\\n edge_ty: PhantomData,\\n}\\n\\nimpl<\\'a, N, E, Ty> Iterator for NodeReferences<\\'a, N, E, Ty>\\nwhere\\n N: \\'a + NodeTrait,\\n E: \\'a,\\n Ty: EdgeType,\\n{\\n type Item = (N, &\\'a N);\\n fn next(&mut self) -> Option {\\n self.iter.next().map(|(n, _)| (*n, n))\\n }\\n}\\n\\nimpl NodeCount for FastGraphMap\\nwhere\\n N: Copy + PartialEq,\\n{\\n fn node_count(self: &Self) -> usize {\\n self.nodes.len()\\n }\\n}\\n\\nimpl GraphBase for FastGraphMap\\nwhere\\n N: Copy + PartialEq,\\n{\\n type EdgeId = (N, N);\\n\\n type NodeId = N;\\n}\\n\\nimpl Visitable for FastGraphMap\\nwhere\\n N: Copy + Ord + Hash,\\n Ty: EdgeType,\\n{\\n type Map = FxHashSet;\\n fn visit_map(&self) -> FxHashSet {\\n FxHashSet::with_capacity_and_hasher(self.node_count(), Default::default())\\n }\\n fn reset_map(&self, map: &mut Self::Map) {\\n map.clear();\\n }\\n}\\n\\nimpl<\\'a, N: \\'a, E, Ty> IntoNeighbors for &\\'a FastGraphMap\\nwhere\\n N: Copy + Ord + Hash,\\n Ty: EdgeType,\\n{\\n type Neighbors = Neighbors<\\'a, N, Ty>;\\n fn neighbors(self, n: Self::NodeId) -> Self::Neighbors {\\n self.neighbors(n)\\n }\\n}\\n\\nimpl<\\'a, N: \\'a, E, Ty> IntoNeighborsDirected for &\\'a FastGraphMap\\nwhere\\n N: Copy + Ord + Hash,\\n Ty: EdgeType,\\n{\\n type NeighborsDirected = NeighborsDirected<\\'a, N, Ty>;\\n fn neighbors_directed(self, n: N, dir: Direction) -> Self::NeighborsDirected {\\n self.neighbors_directed(n, dir)\\n }\\n}\\n',\n", + " 'content_id': '690194cec4a45a1df0eda0049743b5e078420d80',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/bundler/src/util/fast_graph.rs',\n", + " 'size': 24733,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6262341325811002,\n", + " 'avg_line_length': 40.705882352941174,\n", + " 'blob_id': '65bb34ef91348efd361226f643d924468c28de03',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Helper for transforms for the swc project\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_classes/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_classes\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.21.0\"\\n\\n[dependencies]\\nswc_atoms = {version = \"0.2.6\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\n',\n", + " 'content_id': '0581f84f11d59b3d7a52a786f476db73f56ef061',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 69,\n", + " 'path': '/ecmascript/transforms/classes/Cargo.toml',\n", + " 'size': 709,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5659777424483307,\n", + " 'avg_line_length': 23.37984496124031,\n", + " 'blob_id': '047924c78fde5372427004be4075d4352ccef445',\n", + " 'content': 'pub use self::{\\n module::ModuleConfig,\\n optimization::OptimizationConfig,\\n output::OutputConfig,\\n resolve::{AliasConfig, ResolveConfig},\\n};\\nuse rustc_hash::FxHashMap;\\nuse serde::Deserialize;\\nuse std::{collections::HashMap, fmt, marker::PhantomData, path::PathBuf};\\nuse string_enum::StringEnum;\\nuse swc_atoms::JsWord;\\nuse swc_common::{collections::AHashMap, FileName};\\nuse swc_ecma_ast::TargetEnv;\\nuse swc_ecma_parser::JscTarget;\\n\\nmod module;\\nmod optimization;\\nmod output;\\nmod resolve;\\n\\n#[derive(Debug, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\npub struct Config {\\n #[serde(default)]\\n pub working_dir: PathBuf,\\n\\n #[serde(default)]\\n pub mode: Mode,\\n\\n #[serde(default)]\\n pub target: TargetEnv,\\n\\n pub entry: EntryConfig,\\n\\n #[serde(default)]\\n pub output: Option,\\n\\n #[serde(default)]\\n pub module: ModuleConfig,\\n\\n #[serde(default)]\\n pub optimization: Option,\\n\\n #[serde(default)]\\n pub resolve: Option,\\n\\n #[serde(default)]\\n pub options: Option,\\n\\n #[serde(default)]\\n pub external_modules: Vec,\\n\\n #[serde(default)]\\n pub alias: FxHashMap>,\\n}\\n\\nimpl Config {\\n pub fn codegen_target(&self) -> Option {\\n self.options\\n .as_ref()\\n .map(|options| options.codegen_target())\\n .flatten()\\n }\\n}\\n\\n#[derive(StringEnum)]\\npub enum Mode {\\n /// `production`\\n Production,\\n /// `debug`\\n Debug,\\n /// `none`\\n None,\\n}\\n\\nimpl Default for Mode {\\n fn default() -> Self {\\n Mode::None\\n }\\n}\\n\\n#[derive(Debug, Clone, Deserialize)]\\n#[serde(untagged, rename = \"Entry\")]\\npub enum EntryConfig {\\n File(String),\\n Multiple(Vec),\\n Files(AHashMap),\\n}\\n\\nimpl From for HashMap {\\n fn from(c: EntryConfig) -> Self {\\n let mut m = HashMap::default();\\n\\n match c {\\n EntryConfig::File(f) => {\\n let path = PathBuf::from(f);\\n let file_name = path\\n .file_name()\\n .expect(\"entry must be a file, instead of a directory\");\\n m.insert(file_name.to_string_lossy().into(), FileName::Real(path));\\n }\\n EntryConfig::Multiple(files) => {\\n for f in files {\\n let path = PathBuf::from(f);\\n let file_name = path\\n .file_name()\\n .expect(\"entry must be a file, instead of a directory\");\\n m.insert(file_name.to_string_lossy().into(), FileName::Real(path));\\n }\\n }\\n EntryConfig::Files(f) => {\\n return f.into_iter().map(|(k, v)| (k, FileName::Real(v))).collect()\\n }\\n }\\n\\n m\\n }\\n}\\n\\npub struct JsCallback {\\n _f: Box Ret>,\\n _phantom: PhantomData<(T, Ret)>,\\n}\\n\\nimpl fmt::Debug for JsCallback {\\n fn fmt(&self, f: &mut fmt::Formatter<\\'_>) -> fmt::Result {\\n write!(f, \"\")\\n }\\n}\\n',\n", + " 'content_id': 'cab3846496a1dad72b8739d3cb6add541e9bbfce',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 87,\n", + " 'path': '/node/bundler/src/config/mod.rs',\n", + " 'size': 3145,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4339033457249071,\n", + " 'avg_line_length': 28.49561403508772,\n", + " 'blob_id': '4194a1f0f3cdb7994f04a80cffcb68b8983b4404',\n", + " 'content': 'use rustc_hash::FxHashMap;\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{collections::AHashSet, sync::Lrc};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{collect_decls, Id};\\nuse swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\n\\npub fn inline_globals(\\n envs: Lrc>,\\n globals: Lrc>,\\n) -> impl Fold + VisitMut {\\n as_folder(InlineGlobals {\\n envs,\\n globals,\\n bindings: Default::default(),\\n })\\n}\\n\\nstruct InlineGlobals {\\n envs: Lrc>,\\n globals: Lrc>,\\n\\n bindings: AHashSet,\\n}\\n\\nimpl VisitMut for InlineGlobals {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_expr(&mut self, expr: &mut Expr) {\\n expr.visit_mut_children_with(self);\\n\\n match expr {\\n Expr::Ident(Ident { ref sym, span, .. }) => {\\n if self.bindings.contains(&(sym.clone(), span.ctxt)) {\\n return;\\n }\\n\\n // It\\'s ok because we don\\'t recurse into member expressions.\\n if let Some(value) = self.globals.get(sym) {\\n let mut value = value.clone();\\n value.visit_mut_with(self);\\n *expr = value;\\n }\\n\\n return;\\n }\\n\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(ref obj),\\n ref prop,\\n ..\\n }) => match &**obj {\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(first_obj),\\n prop: second_obj,\\n ..\\n }) => match &**first_obj {\\n Expr::Ident(Ident {\\n sym: js_word!(\"process\"),\\n ..\\n }) => match &**second_obj {\\n Expr::Ident(Ident {\\n sym: js_word!(\"env\"),\\n ..\\n }) => match &**prop {\\n Expr::Lit(Lit::Str(Str { value: ref sym, .. }))\\n | Expr::Ident(Ident { ref sym, .. }) => {\\n if let Some(env) = self.envs.get(sym) {\\n *expr = env.clone();\\n return;\\n }\\n }\\n _ => {}\\n },\\n _ => {}\\n },\\n _ => {}\\n },\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_member_expr(&mut self, expr: &mut MemberExpr) {\\n expr.obj.visit_mut_with(self);\\n\\n if expr.computed {\\n expr.prop.visit_mut_with(self);\\n }\\n }\\n\\n fn visit_mut_module(&mut self, module: &mut Module) {\\n self.bindings.extend(collect_decls(&*module));\\n\\n module.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_script(&mut self, script: &mut Script) {\\n self.bindings.extend(collect_decls(&*script));\\n\\n script.visit_mut_children_with(self);\\n }\\n}\\n\\n#[cfg(test)]\\nmod tests {\\n use super::*;\\n use swc_ecma_transforms_testing::{test, Tester};\\n use swc_ecma_utils::DropSpan;\\n use swc_ecma_visit::as_folder;\\n\\n fn mk_map(\\n tester: &mut Tester<\\'_>,\\n values: &[(&str, &str)],\\n is_env: bool,\\n ) -> FxHashMap {\\n let mut m = FxHashMap::default();\\n\\n for (k, v) in values {\\n let v = if is_env {\\n format!(\"\\'{}\\'\", v)\\n } else {\\n (*v).into()\\n };\\n\\n let mut v = tester\\n .apply_transform(\\n as_folder(DropSpan {\\n preserve_ctxt: false,\\n }),\\n \"global.js\",\\n ::swc_ecma_parser::Syntax::default(),\\n &v,\\n )\\n .unwrap();\\n assert_eq!(v.body.len(), 1);\\n let v = match v.body.pop().unwrap() {\\n ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) => *expr,\\n _ => unreachable!(),\\n };\\n\\n m.insert((*k).into(), v);\\n }\\n\\n m\\n }\\n\\n fn envs(tester: &mut Tester<\\'_>, values: &[(&str, &str)]) -> Lrc> {\\n Lrc::new(mk_map(tester, values, true))\\n }\\n\\n fn globals(tester: &mut Tester<\\'_>, values: &[(&str, &str)]) -> Lrc> {\\n Lrc::new(mk_map(tester, values, false))\\n }\\n\\n test!(\\n ::swc_ecma_parser::Syntax::default(),\\n |tester| as_folder(InlineGlobals {\\n envs: envs(tester, &[]),\\n globals: globals(tester, &[]),\\n bindings: Default::default()\\n }),\\n issue_215,\\n r#\"if (process.env.x === \\'development\\') {}\"#,\\n r#\"if (process.env.x === \\'development\\') {}\"#\\n );\\n\\n test!(\\n ::swc_ecma_parser::Syntax::default(),\\n |tester| as_folder(InlineGlobals {\\n envs: envs(tester, &[(\"NODE_ENV\", \"development\")]),\\n globals: globals(tester, &[]),\\n bindings: Default::default()\\n }),\\n node_env,\\n r#\"if (process.env.NODE_ENV === \\'development\\') {}\"#,\\n r#\"if (\\'development\\' === \\'development\\') {}\"#\\n );\\n\\n test!(\\n ::swc_ecma_parser::Syntax::default(),\\n |tester| as_folder(InlineGlobals {\\n envs: envs(tester, &[]),\\n globals: globals(tester, &[(\"__DEBUG__\", \"true\")]),\\n bindings: Default::default()\\n }),\\n inline_globals,\\n r#\"if (__DEBUG__) {}\"#,\\n r#\"if (true) {}\"#\\n );\\n\\n test!(\\n ::swc_ecma_parser::Syntax::default(),\\n |tester| as_folder(InlineGlobals {\\n envs: envs(tester, &[]),\\n globals: globals(tester, &[(\"debug\", \"true\")]),\\n bindings: Default::default()\\n }),\\n non_global,\\n r#\"if (foo.debug) {}\"#,\\n r#\"if (foo.debug) {}\"#\\n );\\n\\n test!(\\n Default::default(),\\n |tester| as_folder(InlineGlobals {\\n envs: envs(tester, &[]),\\n globals: globals(tester, &[]),\\n bindings: Default::default()\\n }),\\n issue_417_1,\\n \"const test = process.env[\\'x\\']\",\\n \"const test = process.env[\\'x\\']\"\\n );\\n\\n test!(\\n Default::default(),\\n |tester| as_folder(InlineGlobals {\\n envs: envs(tester, &[(\"x\", \"FOO\")]),\\n globals: globals(tester, &[]),\\n bindings: Default::default()\\n }),\\n issue_417_2,\\n \"const test = process.env[\\'x\\']\",\\n \"const test = \\'FOO\\'\"\\n );\\n}\\n',\n", + " 'content_id': 'ab0917f860002b1994da5a7bd99e541f95819ff1',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/ecmascript/transforms/optimization/src/inline_globals.rs',\n", + " 'size': 6725,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6275862068965518,\n", + " 'avg_line_length': 38.03846153846154,\n", + " 'blob_id': 'e8aed8f1fadd4dc73c801f3c914a72ed6d895559',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_testing/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_testing\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.36.1\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nansi_term = \"0.12.1\"\\nanyhow = \"1\"\\nserde = \"1\"\\nserde_json = \"1\"\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../../codegen\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\ntempfile = \"3.1.0\"\\ntesting = {version = \"0.14.0\", path = \"../../../testing\"}\\n',\n", + " 'content_id': '489ea7c18aa12e19b09c9b0f7083fa3154746be8',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/transforms/testing/Cargo.toml',\n", + " 'size': 1015,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.475014582928252,\n", + " 'avg_line_length': 25.786458333333332,\n", + " 'blob_id': 'f2f757aed872b2ff981c727787434d10767a0f32',\n", + " 'content': 'use crate::{\\n analyzer::{analyze, ProgramData, UsageAnalyzer},\\n marks::Marks,\\n option::CompressOptions,\\n util::MoudleItemExt,\\n};\\nuse rustc_hash::FxHashMap;\\nuse swc_atoms::js_word;\\nuse swc_common::util::take::Take;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith, VisitWith};\\n\\n/// Optimizer invoked before invoking compressor.\\n///\\n/// - Remove parens.\\npub(crate) fn precompress_optimizer<\\'a>(\\n options: &\\'a CompressOptions,\\n marks: Marks,\\n) -> impl \\'a + VisitMut {\\n PrecompressOptimizer {\\n options,\\n marks,\\n data: Default::default(),\\n fn_decl_count: Default::default(),\\n ctx: Default::default(),\\n }\\n}\\n\\n#[derive(Debug)]\\nstruct PrecompressOptimizer<\\'a> {\\n options: &\\'a CompressOptions,\\n marks: Marks,\\n\\n data: Option,\\n fn_decl_count: FxHashMap,\\n ctx: Ctx,\\n}\\n\\n#[derive(Debug, Default, Clone, Copy)]\\nstruct Ctx {\\n in_var_pat: bool,\\n}\\n\\nimpl PrecompressOptimizer<\\'_> {\\n fn handle_stmts(&mut self, stmts: &mut Vec)\\n where\\n T: for<\\'aa> VisitMutWith> + MoudleItemExt,\\n Vec: for<\\'aa> VisitMutWith> + VisitWith,\\n {\\n if self.data.is_some() {\\n stmts.visit_mut_children_with(self);\\n return;\\n }\\n\\n if self.data.is_none() {\\n let has_decl = stmts.iter().any(|stmt| match stmt.as_module_decl() {\\n Ok(..) | Err(Stmt::Decl(..)) => true,\\n _ => false,\\n });\\n\\n if has_decl {\\n let data = Some(analyze(&*stmts, Some(self.marks)));\\n\\n stmts.visit_mut_children_with(&mut PrecompressOptimizer {\\n options: self.options,\\n marks: self.marks,\\n data,\\n fn_decl_count: Default::default(),\\n ctx: self.ctx,\\n });\\n return;\\n }\\n\\n for stmt in stmts {\\n stmt.visit_mut_with(&mut PrecompressOptimizer {\\n options: self.options,\\n marks: self.marks,\\n data: None,\\n fn_decl_count: Default::default(),\\n ctx: self.ctx,\\n })\\n }\\n return;\\n }\\n }\\n}\\n\\nimpl VisitMut for PrecompressOptimizer<\\'_> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_decl(&mut self, n: &mut Decl) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n Decl::Fn(FnDecl { ident, .. }) => {\\n if ident.sym == js_word!(\"\") {\\n n.take();\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n e.visit_mut_children_with(self);\\n\\n match e {\\n Expr::Paren(p) => {\\n *e = *p.expr.take();\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_fn_decl(&mut self, n: &mut FnDecl) {\\n n.visit_mut_children_with(self);\\n\\n if self.options.dead_code || self.options.unused {\\n if let Some(usage) = self.data.as_ref().unwrap().vars.get(&n.ident.to_id()) {\\n // Remove if variable with same name exists.\\n if usage.var_kind.is_some() && usage.var_initialized && usage.is_fn_local {\\n n.ident.take();\\n return;\\n }\\n\\n if usage.assign_count > 1 {\\n let v = self.fn_decl_count.entry(n.ident.to_id()).or_default();\\n *v += 1;\\n\\n if *v == usage.assign_count {\\n n.ident.take();\\n }\\n }\\n }\\n }\\n }\\n\\n fn visit_mut_module_item(&mut self, n: &mut ModuleItem) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Var(var),\\n ..\\n })) if var.decls.is_empty() => {\\n n.take();\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_module_items(&mut self, n: &mut Vec) {\\n self.handle_stmts(n);\\n\\n n.retain(|s| match s {\\n ModuleItem::Stmt(Stmt::Empty(..)) => false,\\n _ => true,\\n });\\n }\\n\\n fn visit_mut_stmt(&mut self, n: &mut Stmt) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n Stmt::Decl(Decl::Var(var)) if var.decls.is_empty() => {\\n n.take();\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_stmts(&mut self, n: &mut Vec) {\\n self.handle_stmts(n);\\n\\n n.retain(|s| match s {\\n Stmt::Empty(..) => false,\\n _ => true,\\n });\\n }\\n\\n fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator) {\\n let old = self.ctx;\\n self.ctx.in_var_pat = true;\\n n.name.visit_mut_with(self);\\n\\n self.ctx.in_var_pat = false;\\n n.init.visit_mut_with(self);\\n\\n self.ctx = old;\\n }\\n}\\n',\n", + " 'content_id': '67c76ec3e6cf18da8b0f71dab1743dbb8bdb58c7',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 92,\n", + " 'path': '/ecmascript/minifier/src/pass/precompress.rs',\n", + " 'size': 5143,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3557028445180889,\n", + " 'avg_line_length': 32.090078328981726,\n", + " 'blob_id': '1d86b83a16ac74cb4945a80dc5c1ecf045879cbd',\n", + " 'content': 'use super::Optimizer;\\nuse crate::{\\n compress::optimize::Ctx,\\n mode::Mode,\\n util::{idents_used_by, make_number},\\n};\\nuse rustc_hash::FxHashMap;\\nuse std::{\\n collections::HashMap,\\n mem::{replace, swap},\\n};\\nuse swc_atoms::js_word;\\nuse swc_common::{pass::Either, util::take::Take, Spanned, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, undefined, ExprFactory, Id};\\nuse swc_ecma_visit::VisitMutWith;\\n\\n/// Methods related to the option `negate_iife`.\\nimpl Optimizer<\\'_, M>\\nwhere\\n M: Mode,\\n{\\n /// Negates iife, while ignore return value.\\n pub(super) fn negate_iife_ignoring_ret(&mut self, e: &mut Expr) {\\n if !self.options.negate_iife || self.ctx.in_bang_arg || self.ctx.dont_use_negated_iife {\\n return;\\n }\\n\\n let expr = match e {\\n Expr::Call(e) => e,\\n _ => return,\\n };\\n\\n let callee = match &mut expr.callee {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(e) => &mut **e,\\n };\\n\\n match callee {\\n Expr::Fn(..) => {\\n tracing::debug!(\"negate_iife: Negating iife\");\\n *e = Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"!\"),\\n arg: Box::new(e.take()),\\n });\\n return;\\n }\\n _ => {}\\n }\\n }\\n\\n /// Returns true if it did any work.\\n ///\\n ///\\n /// - `iife ? foo : bar` => `!iife ? bar : foo`\\n pub(super) fn negate_iife_in_cond(&mut self, e: &mut Expr) -> bool {\\n let cond = match e {\\n Expr::Cond(v) => v,\\n _ => return false,\\n };\\n\\n let test_call = match &mut *cond.test {\\n Expr::Call(e) => e,\\n _ => return false,\\n };\\n\\n let callee = match &mut test_call.callee {\\n ExprOrSuper::Super(_) => return false,\\n ExprOrSuper::Expr(e) => &mut **e,\\n };\\n\\n match callee {\\n Expr::Fn(..) => {\\n tracing::debug!(\"negate_iife: Swapping cons and alt\");\\n cond.test = Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"!\"),\\n arg: cond.test.take(),\\n }));\\n swap(&mut cond.cons, &mut cond.alt);\\n return true;\\n }\\n _ => false,\\n }\\n }\\n\\n pub(super) fn restore_negated_iife(&mut self, cond: &mut CondExpr) {\\n if !self.ctx.dont_use_negated_iife {\\n return;\\n }\\n\\n match &mut *cond.test {\\n Expr::Unary(UnaryExpr {\\n op: op!(\"!\"), arg, ..\\n }) => match &mut **arg {\\n Expr::Call(CallExpr {\\n span: call_span,\\n callee: ExprOrSuper::Expr(callee),\\n args,\\n ..\\n }) => match &**callee {\\n Expr::Fn(..) => {\\n cond.test = Box::new(Expr::Call(CallExpr {\\n span: *call_span,\\n callee: callee.take().as_callee(),\\n args: args.take(),\\n type_args: Default::default(),\\n }));\\n swap(&mut cond.cons, &mut cond.alt);\\n }\\n _ => {}\\n },\\n _ => {}\\n },\\n _ => {}\\n };\\n }\\n}\\n\\n/// Methods related to iife.\\nimpl Optimizer<\\'_, M>\\nwhere\\n M: Mode,\\n{\\n /// # Exmaple\\n ///\\n /// ## Input\\n ///\\n /// ```ts\\n /// (function(x) {\\n /// (function(y) {\\n /// console.log(7);\\n /// })(7);\\n /// })(7);\\n /// ```\\n ///\\n ///\\n /// ## Output\\n ///\\n /// ```ts\\n /// (function(x) {\\n /// (function(y) {\\n /// console.log(y);\\n /// })(x);\\n /// })(7);\\n /// ```\\n pub(super) fn inline_args_of_iife(&mut self, e: &mut CallExpr) {\\n if self.options.inline == 0 {\\n return;\\n }\\n\\n let has_spread_arg = e.args.iter().any(|v| v.spread.is_some());\\n if has_spread_arg {\\n return;\\n }\\n\\n let callee = match &mut e.callee {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(e) => &mut **e,\\n };\\n\\n fn find_params(callee: &Expr) -> Option> {\\n match callee {\\n Expr::Arrow(callee) => Some(callee.params.iter().collect()),\\n Expr::Fn(callee) => Some(\\n callee\\n .function\\n .params\\n .iter()\\n .map(|param| ¶m.pat)\\n .collect(),\\n ),\\n _ => return None,\\n }\\n }\\n\\n fn find_body(callee: &mut Expr) -> Option> {\\n match callee {\\n Expr::Arrow(e) => match &mut e.body {\\n BlockStmtOrExpr::BlockStmt(b) => Some(Either::Left(b)),\\n BlockStmtOrExpr::Expr(b) => Some(Either::Right(&mut **b)),\\n },\\n Expr::Fn(e) => Some(Either::Left(e.function.body.as_mut().unwrap())),\\n _ => None,\\n }\\n }\\n\\n let params = find_params(&callee);\\n if let Some(params) = params {\\n let mut vars = HashMap::default();\\n // We check for parameter and argument\\n for (idx, param) in params.iter().enumerate() {\\n let arg = e.args.get(idx).map(|v| &v.expr);\\n if let Pat::Ident(param) = ¶m {\\n if let Some(usage) = self\\n .data\\n .as_ref()\\n .and_then(|data| data.vars.get(¶m.to_id()))\\n {\\n if usage.reassigned {\\n continue;\\n }\\n if usage.ref_count != 1 {\\n continue;\\n }\\n }\\n\\n if let Some(arg) = arg {\\n // NOTE\\n //\\n // This function is misdesigned and should be removed.\\n // This is wrong because the order of execution is not guaranteed.\\n match &**arg {\\n Expr::Lit(..) => {}\\n _ => continue,\\n }\\n\\n let should_be_inlined = self.can_be_inlined_for_iife(arg);\\n if should_be_inlined {\\n tracing::trace!(\\n \"iife: Trying to inline argument ({}{:?})\",\\n param.id.sym,\\n param.id.span.ctxt\\n );\\n vars.insert(param.to_id(), arg.clone());\\n }\\n } else {\\n tracing::trace!(\\n \"iife: Trying to inline argument ({}{:?}) (undefined)\",\\n param.id.sym,\\n param.id.span.ctxt\\n );\\n\\n vars.insert(param.to_id(), undefined(param.span()));\\n }\\n }\\n }\\n\\n let ctx = Ctx {\\n in_fn_like: true,\\n top_level: false,\\n ..self.ctx\\n };\\n let mut optimizer = self.with_ctx(ctx);\\n match find_body(callee) {\\n Some(Either::Left(body)) => {\\n tracing::trace!(\"inline: Inlining arguments\");\\n optimizer.inline_vars_in_node(body, vars);\\n }\\n Some(Either::Right(body)) => {\\n tracing::trace!(\"inline: Inlining arguments\");\\n optimizer.inline_vars_in_node(body, vars);\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n pub(super) fn inline_vars_in_node(&mut self, n: &mut N, vars: FxHashMap>)\\n where\\n N: VisitMutWith,\\n {\\n if cfg!(feature = \"debug\") {\\n tracing::trace!(\"inline: inline_vars_in_node\");\\n }\\n let ctx = Ctx {\\n inline_prevented: false,\\n ..self.ctx\\n };\\n let orig_vars = replace(&mut self.state.vars_for_inlining, vars);\\n n.visit_mut_with(&mut *self.with_ctx(ctx));\\n self.state.vars_for_inlining = orig_vars;\\n }\\n\\n /// Fully inlines iife.\\n ///\\n /// # Example\\n ///\\n /// ## Input\\n ///\\n /// ```ts\\n /// (function () {\\n /// return {};\\n /// })().x = 10;\\n /// ```\\n ///\\n /// ## Oupuy\\n ///\\n /// ```ts\\n /// ({\\n /// }).x = 10;\\n /// ```\\n pub(super) fn invoke_iife(&mut self, e: &mut Expr) {\\n if self.options.inline == 0 {\\n let skip = match e {\\n Expr::Call(v) => !v.callee.span().is_dummy(),\\n _ => true,\\n };\\n\\n if skip {\\n return;\\n }\\n }\\n\\n let call = match e {\\n Expr::Call(v) => v,\\n _ => return,\\n };\\n\\n if self.has_noinline(call.span) {\\n return;\\n }\\n\\n let callee = match &mut call.callee {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(e) => &mut **e,\\n };\\n\\n if self.ctx.inline_prevented {\\n tracing::trace!(\"iife: [x] Inline is prevented\");\\n return;\\n }\\n\\n match callee {\\n Expr::Arrow(f) => {\\n if f.is_async {\\n tracing::trace!(\"iife: [x] Cannot inline async fn\");\\n return;\\n }\\n\\n if f.is_generator {\\n tracing::trace!(\"iife: [x] Cannot inline generator\");\\n return;\\n }\\n\\n if self.ctx.in_top_level() && !self.ctx.in_call_arg && self.options.negate_iife {\\n match &f.body {\\n BlockStmtOrExpr::BlockStmt(body) => {\\n let has_decl = body.stmts.iter().any(|stmt| match stmt {\\n Stmt::Decl(..) => true,\\n _ => false,\\n });\\n if has_decl {\\n return;\\n }\\n }\\n BlockStmtOrExpr::Expr(_) => {}\\n }\\n }\\n\\n if f.params.iter().any(|param| !param.is_ident()) {\\n return;\\n }\\n\\n let param_ids = f\\n .params\\n .iter()\\n .map(|p| p.clone().ident().unwrap().id)\\n .collect::>();\\n\\n match &mut f.body {\\n BlockStmtOrExpr::BlockStmt(body) => {\\n let new = self.inline_fn_like(¶m_ids, body, &mut call.args);\\n if let Some(new) = new {\\n self.changed = true;\\n tracing::debug!(\"inline: Inlining a function call (arrow)\");\\n\\n *e = new;\\n }\\n return;\\n }\\n BlockStmtOrExpr::Expr(body) => match &**body {\\n Expr::Lit(Lit::Num(..)) => {\\n if self.ctx.in_obj_of_non_computed_member {\\n return;\\n }\\n }\\n _ => {}\\n },\\n }\\n\\n match &mut f.body {\\n BlockStmtOrExpr::BlockStmt(_) => {\\n // TODO\\n }\\n BlockStmtOrExpr::Expr(body) => {\\n self.changed = true;\\n\\n {\\n let vars = f\\n .params\\n .iter()\\n .cloned()\\n .map(|name| VarDeclarator {\\n span: DUMMY_SP.apply_mark(self.marks.non_top_level),\\n name,\\n init: Default::default(),\\n definite: Default::default(),\\n })\\n .collect::>();\\n\\n if !vars.is_empty() {\\n self.prepend_stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP.apply_mark(self.marks.non_top_level),\\n kind: VarDeclKind::Var,\\n declare: Default::default(),\\n decls: vars,\\n })));\\n }\\n }\\n\\n let mut exprs = vec![];\\n exprs.push(Box::new(make_number(DUMMY_SP, 0.0)));\\n for (idx, param) in f.params.iter().enumerate() {\\n if let Some(arg) = call.args.get_mut(idx) {\\n exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP.apply_mark(self.marks.non_top_level),\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(param.clone())),\\n right: arg.expr.take(),\\n })));\\n }\\n }\\n\\n if call.args.len() > f.params.len() {\\n for arg in &mut call.args[f.params.len()..] {\\n exprs.push(arg.expr.take());\\n }\\n }\\n exprs.push(body.take());\\n\\n tracing::debug!(\"inline: Inlining a call to an arrow function\");\\n *e = Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs,\\n });\\n return;\\n }\\n }\\n }\\n Expr::Fn(f) => {\\n if self.ctx.in_top_level() && !self.ctx.in_call_arg && self.options.negate_iife {\\n let body = f.function.body.as_ref().unwrap();\\n let has_decl = body.stmts.iter().any(|stmt| match stmt {\\n Stmt::Decl(..) => true,\\n _ => false,\\n });\\n if has_decl {\\n tracing::trace!(\"iife: [x] Found decl\");\\n return;\\n }\\n }\\n\\n if f.function.is_async {\\n tracing::trace!(\"iife: [x] Cannot inline async fn\");\\n return;\\n }\\n\\n if f.function.is_generator {\\n tracing::trace!(\"iife: [x] Cannot inline generator\");\\n return;\\n }\\n\\n // Abort if a parameter is complex\\n if f.function.params.iter().any(|param| match param.pat {\\n Pat::Object(..) | Pat::Array(..) | Pat::Assign(..) | Pat::Rest(..) => true,\\n _ => false,\\n }) {\\n tracing::trace!(\"iife: [x] Found complex pattern\");\\n return;\\n }\\n\\n if let Some(i) = &f.ident {\\n if idents_used_by(&f.function.body).contains(&i.to_id()) {\\n tracing::trace!(\"iife: [x] Recursive?\");\\n return;\\n }\\n }\\n\\n for arg in &call.args {\\n if arg.spread.is_some() {\\n tracing::trace!(\"iife: [x] Found spread argument\");\\n return;\\n }\\n match &*arg.expr {\\n Expr::Fn(..) | Expr::Arrow(..) => {\\n tracing::trace!(\"iife: [x] Found callable argument\");\\n return;\\n }\\n _ => {}\\n }\\n }\\n\\n let body = f.function.body.as_mut().unwrap();\\n if body.stmts.is_empty() {\\n *e = *undefined(f.function.span);\\n return;\\n }\\n\\n let param_ids = f\\n .function\\n .params\\n .iter()\\n .map(|p| p.pat.clone().ident().unwrap().id)\\n .collect::>();\\n\\n if !self.can_inline_fn_like(¶m_ids, body) {\\n tracing::trace!(\"iife: [x] Body is not inliable\");\\n return;\\n }\\n\\n let new = self.inline_fn_like(¶m_ids, body, &mut call.args);\\n if let Some(new) = new {\\n self.changed = true;\\n tracing::debug!(\"inline: Inlining a function call\");\\n\\n *e = new;\\n }\\n\\n //\\n }\\n _ => {}\\n }\\n }\\n\\n fn can_inline_fn_like(&self, param_ids: &[Ident], body: &BlockStmt) -> bool {\\n if !body.stmts.iter().all(|stmt| match stmt {\\n Stmt::Decl(Decl::Var(VarDecl {\\n kind: VarDeclKind::Var | VarDeclKind::Let,\\n decls,\\n ..\\n })) => {\\n if decls.iter().any(|decl| match decl.name {\\n Pat::Ident(..) => false,\\n _ => true,\\n }) {\\n return false;\\n }\\n\\n if self.ctx.executed_multiple_time {\\n return false;\\n }\\n\\n true\\n }\\n\\n Stmt::Expr(e) => match &*e.expr {\\n Expr::Await(..) => false,\\n\\n // TODO: Check if paramter is used and inline if call is not related to parameters.\\n Expr::Call(e) => {\\n let used = idents_used_by(&e.callee);\\n param_ids.iter().all(|param| !used.contains(¶m.to_id()))\\n }\\n\\n _ => true,\\n },\\n\\n Stmt::Return(ReturnStmt { arg, .. }) => match arg.as_deref() {\\n Some(Expr::Await(..)) => false,\\n\\n Some(Expr::Lit(Lit::Num(..))) => {\\n if self.ctx.in_obj_of_non_computed_member {\\n false\\n } else {\\n true\\n }\\n }\\n _ => true,\\n },\\n _ => false,\\n }) {\\n return false;\\n }\\n\\n if idents_used_by(&*body)\\n .iter()\\n .any(|v| v.0 == js_word!(\"arguments\"))\\n {\\n return false;\\n }\\n\\n true\\n }\\n\\n fn inline_fn_like(\\n &mut self,\\n params: &[Ident],\\n body: &mut BlockStmt,\\n args: &mut [ExprOrSpread],\\n ) -> Option {\\n if !self.can_inline_fn_like(¶ms, &*body) {\\n return None;\\n }\\n\\n self.changed = true;\\n tracing::debug!(\"inline: Inling an iife\");\\n\\n let mut exprs = vec![];\\n\\n {\\n let vars = params\\n .iter()\\n .cloned()\\n .map(BindingIdent::from)\\n .map(Pat::Ident)\\n .map(|name| VarDeclarator {\\n span: DUMMY_SP.apply_mark(self.marks.non_top_level),\\n name,\\n init: Default::default(),\\n definite: Default::default(),\\n })\\n .collect::>();\\n\\n if !vars.is_empty() {\\n self.prepend_stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP.apply_mark(self.marks.non_top_level),\\n kind: VarDeclKind::Var,\\n declare: Default::default(),\\n decls: vars,\\n })));\\n }\\n }\\n\\n for (idx, param) in params.iter().enumerate() {\\n if let Some(arg) = args.get_mut(idx) {\\n exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP.apply_mark(self.marks.non_top_level),\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(param.clone().into()))),\\n right: arg.expr.take(),\\n })));\\n }\\n }\\n\\n if args.len() > params.len() {\\n for arg in &mut args[params.len()..] {\\n exprs.push(arg.expr.take());\\n }\\n }\\n\\n for mut stmt in body.stmts.take() {\\n match stmt {\\n Stmt::Decl(Decl::Var(ref mut var)) => {\\n for decl in &mut var.decls {\\n if decl.init.is_some() {\\n exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP.apply_mark(self.marks.non_top_level),\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(decl.name.clone())),\\n right: decl.init.take().unwrap(),\\n })))\\n }\\n decl.span = decl.span.apply_mark(self.marks.non_top_level);\\n }\\n\\n self.prepend_stmts.push(stmt);\\n }\\n\\n Stmt::Expr(stmt) => {\\n exprs.push(stmt.expr);\\n }\\n\\n Stmt::Return(stmt) => {\\n let span = stmt.span;\\n let val = *stmt.arg.unwrap_or_else(|| undefined(span));\\n exprs.push(Box::new(val));\\n\\n return Some(Expr::Seq(SeqExpr {\\n span: DUMMY_SP.apply_mark(self.marks.synthesized_seq),\\n exprs,\\n }));\\n }\\n _ => {}\\n }\\n }\\n\\n if let Some(last) = exprs.last_mut() {\\n *last = Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"void\"),\\n arg: last.take(),\\n }));\\n } else {\\n return Some(*undefined(body.span));\\n }\\n\\n Some(Expr::Seq(SeqExpr {\\n span: DUMMY_SP.apply_mark(self.marks.synthesized_seq),\\n exprs,\\n }))\\n }\\n\\n fn can_be_inlined_for_iife(&self, arg: &Expr) -> bool {\\n match arg {\\n Expr::Lit(..) => true,\\n\\n Expr::Unary(UnaryExpr {\\n op: op!(\"void\"),\\n arg,\\n ..\\n })\\n | Expr::Unary(UnaryExpr {\\n op: op!(\"!\"), arg, ..\\n }) => self.can_be_inlined_for_iife(&arg),\\n\\n Expr::Ident(..) => true,\\n\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n computed: false,\\n ..\\n }) => self.can_be_inlined_for_iife(&obj),\\n\\n Expr::Bin(BinExpr {\\n op, left, right, ..\\n }) => match op {\\n op!(bin, \"+\") | op!(\"*\") => {\\n self.can_be_inlined_for_iife(&left) && self.can_be_inlined_for_iife(&right)\\n }\\n _ => false,\\n },\\n\\n Expr::Object(ObjectLit { props, .. }) => {\\n for prop in props {\\n match prop {\\n PropOrSpread::Spread(_) => return false,\\n PropOrSpread::Prop(p) => match &**p {\\n Prop::Shorthand(_) => {}\\n Prop::KeyValue(kv) => {\\n if let PropName::Computed(key) = &kv.key {\\n if !self.can_be_inlined_for_iife(&key.expr) {\\n return false;\\n }\\n }\\n\\n if !self.can_be_inlined_for_iife(&kv.value) {\\n return false;\\n }\\n }\\n Prop::Assign(p) => {\\n if !self.can_be_inlined_for_iife(&p.value) {\\n return false;\\n }\\n }\\n _ => return false,\\n },\\n }\\n }\\n\\n true\\n }\\n\\n Expr::Arrow(ArrowExpr {\\n params,\\n body: BlockStmtOrExpr::Expr(body),\\n is_async: false,\\n is_generator: false,\\n ..\\n }) => params.iter().all(|p| p.is_ident()) && self.can_be_inlined_for_iife(&body),\\n\\n _ => false,\\n }\\n }\\n}\\n',\n", + " 'content_id': '1e5eb3b081b46ddcb2faebca47aa336689933661',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/minifier/src/compress/optimize/iife.rs',\n", + " 'size': 25347,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3138990638990639,\n", + " 'avg_line_length': 38.155378486055774,\n", + " 'blob_id': '97d57a2585fc8ec90282ab51f1bcbb3f756bd258',\n", + " 'content': 'use crate::{\\n analyzer::{ProgramData, UsageAnalyzer},\\n util::{is_hoisted_var_decl_without_init, sort::is_sorted_by_key, IsModuleItem},\\n};\\nuse rustc_hash::FxHashSet;\\nuse swc_common::{pass::Repeated, util::take::Take, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{find_ids, ident::IdentLike, Id, StmtLike};\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith, VisitWith};\\n\\npub(super) struct DeclHoisterConfig {\\n pub hoist_fns: bool,\\n pub hoist_vars: bool,\\n pub _top_level: bool,\\n}\\n\\npub(super) fn decl_hoister(config: DeclHoisterConfig, data: &ProgramData) -> Hoister {\\n Hoister {\\n config,\\n changed: false,\\n data,\\n }\\n}\\n\\npub(super) struct Hoister<\\'a> {\\n config: DeclHoisterConfig,\\n changed: bool,\\n data: &\\'a ProgramData,\\n}\\n\\nimpl Repeated for Hoister<\\'_> {\\n fn changed(&self) -> bool {\\n self.changed\\n }\\n\\n fn reset(&mut self) {\\n self.changed = false;\\n }\\n}\\n\\nimpl Hoister<\\'_> {\\n fn handle_stmt_likes(&mut self, stmts: &mut Vec)\\n where\\n T: StmtLike + IsModuleItem,\\n Vec: for<\\'aa> VisitMutWith> + VisitWith,\\n {\\n stmts.visit_mut_children_with(self);\\n\\n let should_hoist = !is_sorted_by_key(stmts.iter(), |stmt| match stmt.as_stmt() {\\n Some(stmt) => match stmt {\\n Stmt::Decl(Decl::Fn(..)) if self.config.hoist_fns => 1,\\n Stmt::Decl(Decl::Var(var)) if self.config.hoist_vars => {\\n let ids: Vec = find_ids(&var.decls);\\n\\n if ids.iter().any(|id| {\\n self.data\\n .vars\\n .get(id)\\n .map(|v| !v.used_above_decl)\\n .unwrap_or(false)\\n }) {\\n 2\\n } else {\\n 3\\n }\\n }\\n _ => 3,\\n },\\n None => 3,\\n }) || (self.config.hoist_vars\\n && stmts.windows(2).any(|stmts| {\\n is_hoisted_var_decl_without_init(&stmts[0])\\n && is_hoisted_var_decl_without_init(&stmts[1])\\n }));\\n\\n if !should_hoist {\\n return;\\n }\\n self.changed = true;\\n\\n let mut var_decls = vec![];\\n let mut fn_decls = Vec::with_capacity(stmts.len());\\n let mut new_stmts = Vec::with_capacity(stmts.len());\\n let mut done = FxHashSet::default();\\n\\n let mut found_non_var_decl = false;\\n for stmt in stmts.take() {\\n match stmt.try_into_stmt() {\\n Ok(stmt) => {\\n // Seaarch for variable declarations.\\n match stmt {\\n Stmt::Decl(Decl::Fn(..)) if self.config.hoist_fns => {\\n // Move functions to top.\\n fn_decls.push(T::from_stmt(stmt))\\n }\\n\\n Stmt::Decl(Decl::Var(\\n var\\n @\\n VarDecl {\\n kind: VarDeclKind::Var,\\n ..\\n },\\n )) if found_non_var_decl => {\\n let mut exprs = vec![];\\n for decl in var.decls {\\n let ids: Vec = find_ids(&decl.name);\\n\\n for id in ids {\\n if done.insert(id.to_id()) {\\n // If the enclosing function declares parameter with same\\n // name, we can drop a varaible.\\n if decl.init.is_none()\\n && self\\n .data\\n .vars\\n .get(&id.to_id())\\n .map(|v| v.declared_as_fn_param)\\n .unwrap_or(false)\\n {\\n continue;\\n }\\n\\n var_decls.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(id.into()),\\n init: None,\\n definite: false,\\n })\\n }\\n }\\n\\n match decl.init {\\n Some(init) => {\\n //\\n exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: decl.span,\\n left: PatOrExpr::Pat(Box::new(decl.name)),\\n op: op!(\"=\"),\\n right: init,\\n })));\\n }\\n None => {}\\n }\\n }\\n\\n if exprs.is_empty() {\\n continue;\\n }\\n new_stmts.push(T::from_stmt(Stmt::Expr(ExprStmt {\\n span: var.span,\\n expr: if exprs.len() == 1 {\\n exprs.into_iter().next().unwrap()\\n } else {\\n Box::new(Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs,\\n }))\\n },\\n })))\\n }\\n\\n Stmt::Decl(Decl::Var(VarDecl {\\n kind: VarDeclKind::Var,\\n decls,\\n ..\\n })) => {\\n // It can be merged because we didn\\'t found normal statement.\\n //\\n // Code like\\n //\\n // var a = 1;\\n // var b = 3;\\n //\\n // will be merged.\\n var_decls.extend(decls.into_iter().filter(|decl| {\\n // We should preserve if init exists because\\n //\\n // var a = 2, a = 3;\\n //\\n // is valid javascript code.\\n\\n let preserve = match &decl.name {\\n Pat::Ident(name) => {\\n // If the enclosing function declares parameter with same\\n // name, we can drop a varaible. (If it\\'s side-effect free).\\n if decl.init.is_none()\\n && self\\n .data\\n .vars\\n .get(&name.to_id())\\n .map(|v| v.declared_as_fn_param)\\n .unwrap_or(false)\\n {\\n return false;\\n }\\n\\n done.insert(name.to_id())\\n }\\n _ => true,\\n };\\n\\n preserve || decl.init.is_some()\\n }));\\n }\\n\\n Stmt::Decl(Decl::Var(..)) => new_stmts.push(T::from_stmt(stmt)),\\n _ => {\\n match stmt {\\n Stmt::Throw(..) => {\\n fn_decls.push(T::from_stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: var_decls.take(),\\n }))));\\n }\\n _ => {}\\n }\\n found_non_var_decl = true;\\n new_stmts.push(T::from_stmt(stmt))\\n }\\n }\\n }\\n Err(stmt) => new_stmts.push(stmt),\\n }\\n }\\n\\n fn_decls.push(T::from_stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: var_decls,\\n }))));\\n fn_decls.extend(new_stmts);\\n\\n *stmts = fn_decls;\\n }\\n}\\n\\nimpl VisitMut for Hoister<\\'_> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_stmts(&mut self, stmts: &mut Vec) {\\n self.handle_stmt_likes(stmts);\\n }\\n\\n fn visit_mut_module_items(&mut self, stmts: &mut Vec) {\\n self.handle_stmt_likes(stmts);\\n }\\n}\\n',\n", + " 'content_id': '98052c47b4655013f4daa2ec39e9a03465fd33ff',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/minifier/src/compress/hoist_decls.rs',\n", + " 'size': 9828,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6298003072196621,\n", + " 'avg_line_length': 34.50909090909091,\n", + " 'blob_id': 'ee0e6d1ad1855fd6d596e1903d3bccc34454db02',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\n# OUT_DIR is required for testing\\nbuild = \"build.rs\"\\ndescription = \"Very fast ecmascript bundler\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_bundler/\"\\nedition = \"2018\"\\ninclude = [\"Cargo.toml\", \"build.rs\", \"src/**/*.rs\", \"src/**/*.js\"]\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_bundler\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.67.0\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n[features]\\nconcurrent = [\"swc_common/concurrent\", \"dashmap\", \"rayon\", \"indexmap/rayon\"]\\ndefault = []\\n\\n[dependencies]\\nahash = \"0.7\"\\nanyhow = \"1\"\\ncrc = \"1.8\"\\ndashmap = {version = \"4.0.2\", optional = true}\\nindexmap = \"1.6\"\\nis-macro = \"0.1\"\\nonce_cell = \"1\"\\npetgraph = \"0.5\"\\nradix_fmt = \"1\"\\nrayon = {version = \"1\", optional = true}\\nrelative-path = \"1.2\"\\nretain_mut = \"0.1.2\"\\nrustc-hash = \"1.1.0\"\\nswc_atoms = {version = \"0.2.4\", path = \"../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ecmascript/ast\"}\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../ecmascript/codegen\"}\\nswc_ecma_loader = {version = \"0.20.0\", path = \"../ecmascript/loader\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../ecmascript/parser\"}\\nswc_ecma_transforms = {version = \"0.80.0\", path = \"../ecmascript/transforms\", features = [\"optimization\"]}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../ecmascript/utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../ecmascript/visit\"}\\ntracing = \"0.1.28\"\\n\\n[dev-dependencies]\\nhex = \"0.4\"\\nntest = \"0.7.2\"\\npath-clean = \"=0.1.0\"\\nreqwest = {version = \"0.11.4\", features = [\"blocking\"]}\\nsha-1 = \"0.9\"\\nswc_ecma_transforms = {version = \"0.80.0\", path = \"../ecmascript/transforms\", features = [\"react\", \"typescript\"]}\\nswc_node_base = {version = \"0.4.0\", path = \"../node/base\"}\\ntempfile = \"3.1.0\"\\ntesting = {version = \"0.14.0\", path = \"../testing\"}\\nurl = \"2.1.1\"\\nwalkdir = \"2\"\\n',\n", + " 'content_id': '9ba8e0ce1f16770814a8c775465559c425eb6859',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 113,\n", + " 'path': '/bundler/Cargo.toml',\n", + " 'size': 1953,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.43716973836834644,\n", + " 'avg_line_length': 29.54724409448819,\n", + " 'blob_id': 'aa833b59741c94f6c97d56d23dd95ad62299dafa',\n", + " 'content': 'use crate::{\\n get_compiler,\\n util::{CtxtExt, MapErr},\\n};\\nuse anyhow::{bail, Error};\\nuse napi::{CallContext, Env, JsObject, Status, Task};\\nuse rustc_hash::FxHashMap;\\nuse serde::Deserialize;\\nuse std::{\\n panic::{catch_unwind, AssertUnwindSafe},\\n sync::Arc,\\n};\\nuse swc::{\\n config::SourceMapsConfig,\\n resolver::{environment_resolver, paths_resolver},\\n Compiler, TransformOutput,\\n};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_bundler::{BundleKind, Bundler, Load, ModuleRecord, Resolve};\\nuse swc_common::Span;\\nuse swc_ecma_ast::{\\n Bool, Expr, ExprOrSuper, Ident, KeyValueProp, Lit, MemberExpr, MetaPropExpr, PropName, Str,\\n TargetEnv,\\n};\\nuse swc_ecma_loader::NODE_BUILTINS;\\n\\nstruct ConfigItem {\\n loader: Box,\\n resolver: Box,\\n static_items: StaticConfigItem,\\n}\\n\\n#[derive(Debug, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\nstruct StaticConfigItem {\\n #[serde(flatten)]\\n config: swc_node_bundler::config::Config,\\n}\\n\\nstruct BundleTask {\\n swc: Arc,\\n config: ConfigItem,\\n}\\n\\nimpl Task for BundleTask {\\n type Output = FxHashMap;\\n type JsValue = JsObject;\\n\\n fn compute(&mut self) -> napi::Result {\\n let builtins = if let TargetEnv::Node = self.config.static_items.config.target {\\n NODE_BUILTINS\\n .to_vec()\\n .into_iter()\\n .map(JsWord::from)\\n .collect::>()\\n } else {\\n vec![]\\n };\\n\\n // Defaults to es3\\n let codegen_target = self\\n .config\\n .static_items\\n .config\\n .codegen_target()\\n .unwrap_or_default();\\n\\n let res = catch_unwind(AssertUnwindSafe(|| {\\n let bundler = Bundler::new(\\n self.swc.globals(),\\n self.swc.cm.clone(),\\n &self.config.loader,\\n &self.config.resolver,\\n swc_bundler::Config {\\n require: true,\\n external_modules: builtins\\n .into_iter()\\n .chain(\\n self.config\\n .static_items\\n .config\\n .external_modules\\n .iter()\\n .cloned(),\\n )\\n .collect(),\\n ..Default::default()\\n },\\n Box::new(Hook),\\n );\\n\\n let result = bundler\\n .bundle(self.config.static_items.config.entry.clone().into())\\n .convert_err()?;\\n\\n let result = result\\n .into_iter()\\n .map(|bundle| match bundle.kind {\\n BundleKind::Named { name } | BundleKind::Lib { name } => {\\n Ok((name, bundle.module))\\n }\\n BundleKind::Dynamic => bail!(\"unimplemented: dynamic code splitting\"),\\n })\\n .map(|res| {\\n res.and_then(|(k, m)| {\\n // TODO: Source map\\n let minify = self\\n .config\\n .static_items\\n .config\\n .options\\n .as_ref()\\n .map(|v| v.config.minify)\\n .unwrap_or(false);\\n\\n let output = self.swc.print(\\n &m,\\n None,\\n None,\\n true,\\n codegen_target,\\n SourceMapsConfig::Bool(true),\\n // TODO\\n &[],\\n None,\\n minify,\\n None,\\n )?;\\n\\n Ok((k, output))\\n })\\n })\\n .collect::>()\\n .convert_err()?;\\n\\n Ok(result)\\n }));\\n\\n let err = match res {\\n Ok(v) => return v,\\n Err(err) => err,\\n };\\n\\n if let Some(s) = err.downcast_ref::() {\\n return Err(napi::Error::new(\\n Status::GenericFailure,\\n format!(\"panic detected: {}\", s),\\n ));\\n }\\n\\n Err(napi::Error::new(\\n Status::GenericFailure,\\n format!(\"panic detected\"),\\n ))\\n }\\n\\n fn resolve(self, env: Env, output: Self::Output) -> napi::Result {\\n env.to_js_value(&output)?.coerce_to_object()\\n }\\n}\\n\\n#[js_function(1)]\\npub(crate) fn bundle(cx: CallContext) -> napi::Result {\\n let c: Arc = get_compiler(&cx);\\n\\n let static_items: StaticConfigItem = cx.get_deserialized(0)?;\\n\\n let loader = Box::new(swc_node_bundler::loaders::swc::SwcLoader::new(\\n c.clone(),\\n static_items\\n .config\\n .options\\n .as_ref()\\n .cloned()\\n .unwrap_or_else(|| {\\n serde_json::from_value(serde_json::Value::Object(Default::default())).unwrap()\\n }),\\n ));\\n\\n let target_env = static_items.config.target;\\n\\n let paths = static_items.config.options.as_ref().map(|options| {\\n let paths: Vec<(String, Vec)> = options\\n .config\\n .jsc\\n .paths\\n .iter()\\n .map(|(k, v)| (k.clone(), v.clone()))\\n .collect();\\n (options.config.jsc.base_url.clone(), paths)\\n });\\n\\n let alias = static_items\\n .config\\n .alias\\n .get(&target_env)\\n .map(|a| a.clone())\\n .unwrap_or_else(|| Default::default());\\n\\n let resolver: Box = if let Some((base_url, paths)) = paths {\\n Box::new(paths_resolver(target_env, alias, base_url, paths))\\n } else {\\n Box::new(environment_resolver(target_env, alias))\\n };\\n\\n cx.env\\n .spawn(BundleTask {\\n swc: c.clone(),\\n config: ConfigItem {\\n loader,\\n resolver,\\n static_items,\\n },\\n })\\n .map(|t| t.promise_object())\\n}\\n\\nstruct Hook;\\n\\nimpl swc_bundler::Hook for Hook {\\n fn get_import_meta_props(\\n &self,\\n span: Span,\\n module_record: &ModuleRecord,\\n ) -> Result, Error> {\\n Ok(vec![\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(js_word!(\"url\"), span)),\\n value: Box::new(Expr::Lit(Lit::Str(Str {\\n span,\\n value: module_record.file_name.to_string().into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n },\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(js_word!(\"main\"), span)),\\n value: Box::new(if module_record.is_entry {\\n Expr::Member(MemberExpr {\\n span,\\n obj: ExprOrSuper::Expr(Box::new(Expr::MetaProp(MetaPropExpr {\\n meta: Ident::new(js_word!(\"import\"), span),\\n prop: Ident::new(js_word!(\"meta\"), span),\\n }))),\\n prop: Box::new(Expr::Ident(Ident::new(js_word!(\"main\"), span))),\\n computed: false,\\n })\\n } else {\\n Expr::Lit(Lit::Bool(Bool { span, value: false }))\\n }),\\n },\\n ])\\n }\\n}\\n',\n", + " 'content_id': 'b5c6b5bef4a0590d7d60e83cca01cec22babe477',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 95,\n", + " 'path': '/node/binding/src/bundle.rs',\n", + " 'size': 7759,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.36202232517645594,\n", + " 'avg_line_length': 35.671607753705814,\n", + " 'blob_id': 'dc1d559c050e75c94c3c22e4a5b4d994e783159d',\n", + " 'content': 'use self::metadata::{Metadata, ParamMetadata};\\nuse super::{contains_decorator, DecoratorFinder};\\nuse rustc_hash::FxHashMap;\\nuse smallvec::SmallVec;\\nuse std::mem::{replace, take};\\nuse swc_common::{util::move_map::MoveMap, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::helper;\\nuse swc_ecma_utils::{\\n alias_if_required, default_constructor, ident::IdentLike, member_expr, prepend, private_ident,\\n prop_name_to_expr_value, quote_ident, replace_ident, undefined, ExprFactory, Id,\\n ModuleItemLike, StmtLike,\\n};\\nuse swc_ecma_visit::{noop_fold_type, Fold, FoldWith, Node, Visit, VisitWith};\\n\\nmod metadata;\\n\\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\\nenum EnumKind {\\n Mixed,\\n Str,\\n Num,\\n}\\n\\n#[derive(Debug)]\\npub(super) struct Legacy {\\n metadata: bool,\\n uninitialized_vars: Vec,\\n initialized_vars: Vec,\\n exports: Vec,\\n enums: FxHashMap,\\n}\\n\\npub(super) fn new(metadata: bool) -> Legacy {\\n Legacy {\\n metadata,\\n uninitialized_vars: Default::default(),\\n initialized_vars: Default::default(),\\n exports: Default::default(),\\n enums: Default::default(),\\n }\\n}\\n\\nimpl Visit for Legacy {\\n fn visit_ts_enum_decl(&mut self, e: &TsEnumDecl, _: &dyn Node) {\\n let enum_kind = e\\n .members\\n .iter()\\n .map(|member| member.init.as_ref())\\n .map(|init| match init {\\n Some(e) => match &**e {\\n Expr::Lit(lit) => match lit {\\n Lit::Str(_) => EnumKind::Str,\\n Lit::Num(_) => EnumKind::Num,\\n _ => EnumKind::Mixed,\\n },\\n _ => EnumKind::Mixed,\\n },\\n None => EnumKind::Num,\\n })\\n .fold(None, |opt: Option, item| {\\n //\\n let a = match item {\\n EnumKind::Mixed => return Some(EnumKind::Mixed),\\n _ => item,\\n };\\n\\n let b = match opt {\\n Some(EnumKind::Mixed) => return Some(EnumKind::Mixed),\\n Some(v) => v,\\n None => return Some(item),\\n };\\n if a == b {\\n return Some(a);\\n } else {\\n return Some(EnumKind::Mixed);\\n }\\n });\\n if let Some(kind) = enum_kind {\\n self.enums.insert(e.id.to_id(), kind);\\n }\\n }\\n}\\n\\nimpl Fold for Legacy {\\n noop_fold_type!();\\n\\n fn fold_decl(&mut self, decl: Decl) -> Decl {\\n let decl: Decl = decl.fold_children_with(self);\\n\\n match decl {\\n Decl::Class(c) => {\\n let expr = self.handle(ClassExpr {\\n class: c.class,\\n ident: Some(c.ident.clone()),\\n });\\n\\n return Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Let,\\n declare: false,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(c.ident.into()),\\n init: Some(expr),\\n definite: false,\\n }],\\n });\\n }\\n\\n _ => {}\\n }\\n\\n decl\\n }\\n\\n fn fold_expr(&mut self, e: Expr) -> Expr {\\n let e: Expr = e.fold_children_with(self);\\n\\n match e {\\n Expr::Class(e) => {\\n let expr = self.handle(e);\\n\\n return *expr;\\n }\\n\\n _ => {}\\n }\\n\\n e\\n }\\n\\n fn fold_module(&mut self, m: Module) -> Module {\\n // Collect required information.\\n // For example, value type of enum affects codegen\\n m.visit_with(&Invalid { span: DUMMY_SP }, self);\\n\\n let mut m = m.fold_children_with(self);\\n\\n if !self.uninitialized_vars.is_empty() {\\n prepend(\\n &mut m.body,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: take(&mut self.uninitialized_vars),\\n declare: false,\\n }))\\n .into(),\\n );\\n }\\n\\n if !self.exports.is_empty() {\\n let decl = ModuleDecl::ExportNamed(NamedExport {\\n span: DUMMY_SP,\\n specifiers: take(&mut self.exports),\\n src: None,\\n type_only: false,\\n asserts: None,\\n });\\n\\n m.body.push(decl.into());\\n }\\n\\n m\\n }\\n\\n fn fold_module_item(&mut self, item: ModuleItem) -> ModuleItem {\\n let item: ModuleItem = item.fold_children_with(self);\\n\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl: DefaultDecl::Class(c),\\n ..\\n })) => {\\n let export_ident = c.ident.clone().unwrap_or_else(|| private_ident!(\"_class\"));\\n\\n let expr = self.handle(c);\\n\\n self.exports\\n .push(ExportSpecifier::Named(ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: export_ident.clone(),\\n exported: Some(quote_ident!(\"default\")),\\n is_type_only: false,\\n }));\\n\\n return ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Let,\\n declare: false,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(export_ident.into()),\\n init: Some(expr),\\n definite: false,\\n }],\\n })));\\n }\\n\\n _ => {}\\n }\\n\\n item\\n }\\n\\n fn fold_script(&mut self, s: Script) -> Script {\\n let mut s = s.fold_children_with(self);\\n\\n if !self.uninitialized_vars.is_empty() {\\n prepend(\\n &mut s.body,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: replace(&mut self.uninitialized_vars, Default::default()),\\n declare: false,\\n })),\\n );\\n }\\n\\n s\\n }\\n\\n fn fold_module_items(&mut self, n: Vec) -> Vec {\\n self.fold_stmt_like(n)\\n }\\n\\n fn fold_stmts(&mut self, n: Vec) -> Vec {\\n self.fold_stmt_like(n)\\n }\\n}\\n\\nimpl Legacy {\\n fn fold_stmt_like(&mut self, stmts: Vec) -> Vec\\n where\\n T: FoldWith + VisitWith + StmtLike + ModuleItemLike,\\n Vec: VisitWith,\\n {\\n if !contains_decorator(&stmts) {\\n return stmts;\\n }\\n\\n let mut buf = Vec::with_capacity(stmts.len() + 4);\\n\\n for stmt in stmts {\\n if !contains_decorator(&stmt) {\\n buf.push(stmt);\\n continue;\\n }\\n\\n let stmt = stmt.fold_with(self);\\n\\n if !self.initialized_vars.is_empty() {\\n buf.push(T::from_stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: replace(&mut self.initialized_vars, Default::default()),\\n declare: false,\\n }))));\\n }\\n\\n buf.push(stmt);\\n }\\n\\n buf\\n }\\n}\\n\\nimpl Legacy {\\n fn handle(&mut self, mut c: ClassExpr) -> Box {\\n if self.metadata {\\n let i = c.ident.clone();\\n\\n c = c.fold_with(&mut ParamMetadata).fold_with(&mut Metadata {\\n enums: &self.enums,\\n class_name: i.as_ref(),\\n });\\n }\\n\\n let cls_ident = private_ident!(\"_class\");\\n let cls_name = c.ident.clone();\\n\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(cls_ident.clone().into()),\\n init: None,\\n definite: false,\\n });\\n\\n // We initialize decorators lazily.\\n //\\n // See https://github.com/swc-project/swc/issues/1278\\n let mut dec_init_exprs = vec![];\\n\\n // Injected to sequence expression which is wrapped with parenthesis.\\n let mut extra_exprs = vec![];\\n // Injected to constructor\\n let mut constructor_stmts = SmallVec::<[_; 8]>::new();\\n\\n let prototype = MemberExpr {\\n span: DUMMY_SP,\\n obj: ExprOrSuper::Expr(Box::new(Expr::Ident(cls_ident.clone()))),\\n prop: Box::new(quote_ident!(\"prototype\").into()),\\n computed: false,\\n };\\n\\n c.class.body = c.class.body.move_flat_map(|m| match m {\\n ClassMember::Method(mut m)\\n if !m.function.decorators.is_empty()\\n || m.function.params.iter().any(|p| !p.decorators.is_empty()) =>\\n {\\n let prototype = if m.is_static {\\n cls_ident.clone().as_arg()\\n } else {\\n // _class2.prototype,\\n prototype.clone().as_arg()\\n };\\n\\n // _applyDecoratedDescriptor(_class2.prototype, \"method2\", [_dec7, _dec8],\\n // Object.getOwnPropertyDescriptor(_class2.prototype, \"method2\"),\\n // _class2.prototype)\\n\\n let mut dec_exprs = vec![];\\n let mut dec_inits = vec![];\\n for mut dec in m.function.decorators.into_iter() {\\n let (i, aliased) = alias_if_required(&dec.expr, \"_dec\");\\n if aliased {\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(i.clone().into()),\\n init: None,\\n definite: false,\\n });\\n\\n // We use _class.staticField instead of Person.staticField because while\\n // initializing the class,\\n //\\n // _dec = Debounce(Person.debounceTime)\\n //\\n // fails while\\n //\\n // _dec = Debounce(_class.debounceTime)\\n //\\n // works.\\n //\\n // See: https://github.com/swc-project/swc/issues/823\\n let right = if let Some(cls_name) = cls_name.clone() {\\n replace_ident(&mut dec.expr, cls_name.to_id(), &cls_ident);\\n\\n dec.expr\\n } else {\\n dec.expr\\n };\\n\\n dec_inits.push(Box::new(Expr::Assign(AssignExpr {\\n span: dec.span,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(i.clone().into()))),\\n right,\\n })));\\n }\\n\\n dec_exprs.push(Some(i.as_arg()))\\n }\\n\\n let name = match &m.key {\\n PropName::Computed(e) => {\\n let (name, aliased) = alias_if_required(&e.expr, \"key\");\\n if aliased {\\n let mut init = e.expr.clone();\\n if let Some(name) = &cls_name {\\n replace_ident(&mut init, name.to_id(), &cls_ident);\\n }\\n\\n dec_init_exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(name.clone().into()))),\\n right: init,\\n })));\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(name.clone().into()),\\n init: None,\\n definite: Default::default(),\\n })\\n }\\n\\n Expr::Ident(name)\\n }\\n _ => prop_name_to_expr_value(m.key.clone()),\\n };\\n\\n {\\n // https://github.com/swc-project/swc/issues/863\\n let mut new_params = Vec::with_capacity(m.function.params.len());\\n for (index, param) in m.function.params.into_iter().enumerate() {\\n for dec in param.decorators {\\n //\\n extra_exprs.push(Box::new(Expr::Call(CallExpr {\\n span: dec.span,\\n callee: dec.expr.as_callee(),\\n args: vec![\\n prototype.clone(),\\n name.clone().as_arg(),\\n Lit::Num(Number {\\n span: param.span,\\n value: index as _,\\n })\\n .as_arg(),\\n ],\\n type_args: None,\\n })))\\n }\\n\\n new_params.push(Param {\\n decorators: Default::default(),\\n ..param\\n });\\n }\\n m.function.params = new_params;\\n }\\n\\n let callee = helper!(apply_decorated_descriptor, \"applyDecoratedDescriptor\");\\n\\n extra_exprs.extend(dec_inits);\\n\\n extra_exprs.push(Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee,\\n // (_class2.prototype, \"method2\", [_dec7, _dec8],\\n // Object.getOwnPropertyDescriptor(_class2.prototype, \"method2\"),\\n // _class2.prototype)\\n args: vec![\\n prototype.clone(),\\n // \"method2\"\\n name.clone().as_arg(),\\n // [_dec7, _dec8],\\n ArrayLit {\\n span: DUMMY_SP,\\n elems: dec_exprs,\\n }\\n .as_arg(),\\n // Object.getOwnPropertyDescriptor(_class2.prototype, \"method2\"),\\n CallExpr {\\n span: DUMMY_SP,\\n callee: member_expr!(DUMMY_SP, Object.getOwnPropertyDescriptor)\\n .as_callee(),\\n args: vec![prototype.clone(), name.as_arg()],\\n type_args: None,\\n }\\n .as_arg(),\\n // _class2.prototype\\n prototype.clone(),\\n ],\\n type_args: None,\\n })));\\n\\n Some(ClassMember::Method(ClassMethod {\\n function: Function {\\n decorators: vec![],\\n ..m.function\\n },\\n ..m\\n }))\\n }\\n\\n ClassMember::ClassProp(p) if !p.decorators.is_empty() => {\\n let prototype = if p.is_static {\\n cls_ident.clone().as_arg()\\n } else {\\n // _class2.prototype,\\n prototype.clone().as_arg()\\n };\\n\\n //\\n let descriptor = private_ident!(\"_descriptor\");\\n if !p.is_static {\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(descriptor.clone().into()),\\n init: None,\\n definite: false,\\n });\\n }\\n\\n let mut value = Some(p.value);\\n\\n let mut dec_exprs = vec![];\\n for mut dec in p.decorators.into_iter() {\\n let (i, aliased) = alias_if_required(&dec.expr, \"_dec\");\\n if aliased {\\n if let Some(name) = &cls_name {\\n replace_ident(&mut dec.expr, name.to_id(), &cls_ident);\\n }\\n\\n dec_init_exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(i.clone().into()))),\\n right: dec.expr,\\n })));\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(i.clone().into()),\\n init: None,\\n definite: false,\\n });\\n }\\n\\n dec_exprs.push(Some(i.as_arg()))\\n }\\n\\n // TODO: Handle s prop name\\n let name = match *p.key {\\n Expr::Ident(ref i) => Box::new(Expr::Lit(Lit::Str(Str {\\n span: i.span,\\n value: i.sym.clone(),\\n has_escape: false,\\n kind: StrKind::Normal {\\n contains_quote: false,\\n },\\n }))),\\n _ => p.key.clone(),\\n };\\n let init = private_ident!(\"_init\");\\n if p.is_static {\\n self.uninitialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(init.clone().into()),\\n init: None,\\n definite: false,\\n });\\n }\\n\\n let mut property_descriptor = Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: vec![\\n // configurable: true,\\n PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: quote_ident!(\"configurable\").into(),\\n value: Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n }))), // enumerable: true,\\n PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: quote_ident!(\"enumerable\").into(),\\n value: Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n }))),\\n // writable: true,\\n PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: quote_ident!(\"writable\").into(),\\n value: Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n }))),\\n // initializer: function () {\\n // return 2;\\n // }\\n PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: quote_ident!(\"initializer\").into(),\\n value: if value.is_some() && value.as_ref().unwrap().is_some() {\\n Box::new(Expr::Fn(FnExpr {\\n ident: None,\\n function: Function {\\n decorators: Default::default(),\\n is_generator: false,\\n is_async: false,\\n span: DUMMY_SP,\\n params: vec![],\\n\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![ReturnStmt {\\n span: DUMMY_SP,\\n arg: if p.is_static {\\n Some(Box::new(Expr::Ident(init.clone())))\\n } else {\\n value.take().unwrap()\\n },\\n }\\n .into()],\\n }),\\n\\n type_params: Default::default(),\\n return_type: Default::default(),\\n },\\n }))\\n } else {\\n undefined(DUMMY_SP)\\n // Box::new(Expr::Lit(Lit::Null(Null { span:\\n // DUMMY_SP })))\\n },\\n }))),\\n ],\\n });\\n\\n if p.is_static {\\n property_descriptor = Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs: vec![\\n Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(init.clone().into()))),\\n op: op!(\"=\"),\\n // Object.getOwnPropertyDescriptor(_class, \"enumconfwrite\")\\n right: Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: member_expr!(DUMMY_SP, Object.getOwnPropertyDescriptor)\\n .as_callee(),\\n args: vec![cls_ident.clone().as_arg(), name.clone().as_arg()],\\n type_args: Default::default(),\\n })),\\n })),\\n // _init = _init ? _init.value : void 0\\n Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(init.clone().into()))),\\n op: op!(\"=\"),\\n right: Box::new(Expr::Cond(CondExpr {\\n span: DUMMY_SP,\\n test: Box::new(Expr::Ident(init.clone())),\\n cons: Box::new(init.clone().make_member(quote_ident!(\"value\"))),\\n alt: undefined(DUMMY_SP),\\n })),\\n })),\\n Box::new(property_descriptor),\\n ],\\n });\\n }\\n\\n // _applyDecoratedDescriptor(_class2.prototype, \"prop2\", [_dec9, _dec10], {\\n // configurable: true,\\n // enumerable: true,\\n // writable: true,\\n // `: function () {\\n // return 2;\\n // }\\n // }))\\n let call_expr = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(apply_decorated_descriptor, \"applyDecoratedDescriptor\"),\\n args: {\\n if p.is_static {\\n vec![\\n prototype,\\n name.clone().as_arg(),\\n ArrayLit {\\n span: DUMMY_SP,\\n elems: dec_exprs,\\n }\\n .as_arg(),\\n property_descriptor.as_arg(),\\n cls_ident.clone().as_arg(),\\n ]\\n } else {\\n vec![\\n prototype,\\n name.clone().as_arg(),\\n ArrayLit {\\n span: DUMMY_SP,\\n elems: dec_exprs,\\n }\\n .as_arg(),\\n property_descriptor.as_arg(),\\n ]\\n }\\n },\\n type_args: Default::default(),\\n }));\\n\\n if !p.is_static {\\n extra_exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(descriptor.clone().into()))),\\n right: call_expr,\\n })));\\n } else {\\n extra_exprs.push(call_expr);\\n }\\n\\n if !p.is_static {\\n constructor_stmts.push(\\n CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(\\n initializer_define_property,\\n \"initializerDefineProperty\"\\n ),\\n args: vec![\\n ThisExpr { span: DUMMY_SP }.as_arg(),\\n name.as_arg(),\\n descriptor.as_arg(),\\n ThisExpr { span: DUMMY_SP }.as_arg(),\\n ],\\n type_args: None,\\n }\\n .into_stmt(),\\n );\\n }\\n\\n if p.is_static {\\n Some(\\n ClassProp {\\n decorators: vec![],\\n value: value.take().unwrap(),\\n ..p\\n }\\n .into(),\\n )\\n } else {\\n None\\n }\\n }\\n\\n _ => Some(m),\\n });\\n\\n if !constructor_stmts.is_empty() {\\n {\\n // Create constructors as required\\n\\n let has = c.class.body.iter().any(|m| match m {\\n ClassMember::Constructor(..) => true,\\n _ => false,\\n });\\n\\n if !has {\\n c.class\\n .body\\n .push(ClassMember::Constructor(default_constructor(\\n c.class.super_class.is_some(),\\n )))\\n }\\n }\\n\\n let constructor = c\\n .class\\n .body\\n .iter_mut()\\n .filter_map(|m| match m {\\n ClassMember::Constructor(c) => Some(c),\\n _ => None,\\n })\\n .next()\\n .unwrap();\\n\\n if constructor.body.is_none() {\\n constructor.body = Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![],\\n });\\n }\\n\\n let decorate_stmts_insert_position = constructor\\n .body\\n .as_ref()\\n .unwrap()\\n .stmts\\n .iter()\\n .position(|stmt| {\\n if let Stmt::Expr(expr) = stmt {\\n let expr = expr.expr.as_ref();\\n if let Expr::Call(call) = expr {\\n if let ExprOrSuper::Super(_) = call.callee {\\n return true;\\n }\\n }\\n }\\n\\n return false;\\n })\\n .map_or(0, |p| p + 1);\\n\\n constructor.body.as_mut().unwrap().stmts.splice(\\n decorate_stmts_insert_position..decorate_stmts_insert_position,\\n constructor_stmts,\\n );\\n }\\n\\n let cls_assign = Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(cls_ident.clone().into()))),\\n right: Box::new(Expr::Class(ClassExpr {\\n ident: c.ident.clone(),\\n class: Class {\\n decorators: vec![],\\n ..c.class\\n },\\n })),\\n }));\\n\\n let var_init = Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: cls_assign,\\n op: op!(\"||\"),\\n right: Box::new(Expr::Ident(cls_ident.clone())),\\n }));\\n\\n let mut extra_exprs = {\\n let mut buf = dec_init_exprs;\\n buf.extend(extra_exprs);\\n buf\\n };\\n\\n let expr = self.apply(\\n &cls_ident,\\n if extra_exprs.is_empty() {\\n var_init\\n } else {\\n extra_exprs.insert(0, var_init);\\n // Return value.\\n extra_exprs.push(Box::new(Expr::Ident(cls_ident.clone())));\\n\\n Box::new(Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs: extra_exprs,\\n }))\\n },\\n c.class.decorators,\\n );\\n\\n expr\\n }\\n\\n /// Apply class decorators.\\n fn apply(\\n &mut self,\\n class_ident: &Ident,\\n mut expr: Box,\\n decorators: Vec,\\n ) -> Box {\\n for dec in decorators.into_iter().rev() {\\n let (i, aliased) = alias_if_required(&dec.expr, \"_dec\");\\n if aliased {\\n self.initialized_vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(i.clone().into()),\\n init: Some(dec.expr),\\n definite: false,\\n });\\n }\\n\\n let dec_call_expr = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: i.as_callee(),\\n args: vec![expr.as_arg()],\\n type_args: None,\\n }));\\n\\n // _class = dec(_class = function() {}) || _class\\n let class_expr = Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(class_ident.clone().into()))),\\n op: op!(\"=\"),\\n right: Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: dec_call_expr,\\n op: op!(\"||\"),\\n right: Box::new(Expr::Ident(class_ident.clone())),\\n })),\\n }));\\n\\n expr = class_expr;\\n }\\n\\n expr\\n }\\n}\\n',\n", + " 'content_id': '8524e16ea2806dc615f86cc70955768487bea1b3',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/transforms/proposal/src/decorators/legacy.rs',\n", + " 'size': 32161,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.612,\n", + " 'avg_line_length': 36.03703703703704,\n", + " 'blob_id': '5e666a386507a7272e7b15c0ab8c2ae76906b192',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Ecmascript code generator for the swc project.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_codegen/\"\\nedition = \"2018\"\\ninclude = [\"Cargo.toml\", \"src/**/*.rs\"]\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_codegen\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.74.1\"\\n\\n[dependencies]\\nbitflags = \"1\"\\nmemchr = \"2.4.1\"\\nnum-bigint = {version = \"0.2\", features = [\"serde\"]}\\nonce_cell = \"1.8.0\"\\nsourcemap = \"6\"\\nswc_atoms = {version = \"0.2\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_codegen_macros = {version = \"0.6.0\", path = \"./macros\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../parser\"}\\n\\n[dev-dependencies]\\nswc_common = {version = \"0.13.0\", path = \"../../common\", features = [\"sourcemap\"]}\\nswc_node_base = {version = \"0.4.0\", path = \"../../node/base\"}\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\n',\n", + " 'content_id': '26d2f14cca94b841da33b8cab38ce6238297400e',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 82,\n", + " 'path': '/ecmascript/codegen/Cargo.toml',\n", + " 'size': 1000,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.37189708280485595,\n", + " 'avg_line_length': 33.1733746130031,\n", + " 'blob_id': 'ea2f3b3233934032e8c3c6184a6d171cadf7dffd',\n", + " 'content': \"use rustc_hash::FxHashMap;\\nuse swc_atoms::JsWord;\\nuse swc_common::{\\n util::{move_map::MoveMap, take::Take},\\n Spanned, SyntaxContext, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};\\n#[derive(Debug, Default)]\\npub(super) struct Operations {\\n pub rename: FxHashMap,\\n}\\n\\npub(super) struct Operator<'a>(pub &'a Operations);\\n\\nimpl<'a> VisitMut for Operator<'a> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_module_items(&mut self, items: &mut Vec) {\\n let mut stmts = Vec::with_capacity(items.len());\\n\\n for mut item in items.take() {\\n let span = item.span();\\n\\n macro_rules! export {\\n ($orig:expr, $ident:expr) => {\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span,\\n specifiers: vec![ExportSpecifier::Named(ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: $ident,\\n exported: Some($orig),\\n is_type_only: false,\\n })],\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )));\\n };\\n }\\n\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl:\\n Decl::Class(ClassDecl {\\n mut ident,\\n mut class,\\n declare,\\n }),\\n })) => {\\n class.visit_mut_with(self);\\n let orig_ident = ident.clone();\\n match self.rename_ident(&mut ident) {\\n Ok(..) => {\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Class(ClassDecl {\\n ident: ident.clone(),\\n class,\\n declare,\\n }))));\\n export!(orig_ident, ident);\\n }\\n Err(..) => {\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl: Decl::Class(ClassDecl {\\n ident,\\n class,\\n declare,\\n }),\\n })))\\n }\\n }\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl:\\n Decl::Fn(FnDecl {\\n mut ident,\\n mut function,\\n declare,\\n }),\\n })) => {\\n function.visit_mut_with(self);\\n let orig_ident = ident.clone();\\n match self.rename_ident(&mut ident) {\\n Ok(..) => {\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Fn(FnDecl {\\n ident: ident.clone(),\\n function,\\n declare,\\n }))));\\n export!(orig_ident, ident);\\n }\\n Err(..) => {\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl: Decl::Fn(FnDecl {\\n ident,\\n function,\\n declare,\\n }),\\n })))\\n }\\n }\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Var(var),\\n ..\\n })) => {\\n let decls = var.decls;\\n\\n let mut renamed: Vec = vec![];\\n let decls = decls.move_map(|mut decl| {\\n decl.name.visit_mut_with(&mut VarFolder {\\n orig: self,\\n renamed: &mut renamed,\\n });\\n decl.init.visit_mut_with(self);\\n decl\\n });\\n if renamed.is_empty() {\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl: Decl::Var(VarDecl { decls, ..var }),\\n })));\\n continue;\\n }\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n decls,\\n ..var\\n }))));\\n stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span,\\n specifiers: renamed,\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )));\\n }\\n _ => {\\n item.visit_mut_with(self);\\n stmts.push(item)\\n }\\n }\\n }\\n\\n *items = stmts\\n }\\n\\n /// Preserve key of properties.\\n fn visit_mut_assign_pat_prop(&mut self, p: &mut AssignPatProp) {\\n match &mut p.value {\\n Some(value) => {\\n value.visit_mut_children_with(self);\\n }\\n None => {}\\n }\\n }\\n\\n fn visit_mut_export_named_specifier(&mut self, s: &mut ExportNamedSpecifier) {\\n if s.exported.is_some() {\\n s.orig.visit_mut_with(self);\\n return;\\n }\\n\\n let exported = s.orig.clone();\\n\\n match self.rename_ident(&mut s.orig) {\\n Ok(..) => {\\n s.exported = Some(exported);\\n }\\n Err(..) => {}\\n }\\n }\\n\\n fn visit_mut_ident(&mut self, ident: &mut Ident) {\\n match self.rename_ident(ident) {\\n Ok(i) | Err(i) => i,\\n }\\n }\\n\\n fn visit_mut_import_named_specifier(&mut self, s: &mut ImportNamedSpecifier) {\\n if s.imported.is_some() {\\n s.local.visit_mut_with(self);\\n return;\\n }\\n\\n let imported = s.local.clone();\\n let local = self.rename_ident(&mut s.local);\\n\\n match local {\\n Ok(..) => {\\n s.imported = Some(imported);\\n }\\n Err(..) => {}\\n }\\n }\\n\\n /// Preserve key of properties.\\n fn visit_mut_key_value_pat_prop(&mut self, p: &mut KeyValuePatProp) {\\n p.key.visit_mut_with(self);\\n p.value.visit_mut_with(self);\\n }\\n\\n fn visit_mut_key_value_prop(&mut self, p: &mut KeyValueProp) {\\n p.key.visit_mut_with(self);\\n p.value.visit_mut_with(self);\\n }\\n\\n fn visit_mut_member_expr(&mut self, expr: &mut MemberExpr) {\\n expr.span.visit_mut_with(self);\\n expr.obj.visit_mut_with(self);\\n\\n if expr.computed {\\n expr.prop.visit_mut_with(self)\\n }\\n }\\n\\n fn visit_mut_object_pat_prop(&mut self, n: &mut ObjectPatProp) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n ObjectPatProp::Assign(p) => {\\n let mut renamed = p.key.clone();\\n match self.rename_ident(&mut renamed) {\\n Ok(..) => {\\n *n = KeyValuePatProp {\\n key: PropName::Ident(p.key.take()),\\n value: match p.value.take() {\\n Some(default_expr) => Box::new(Pat::Assign(AssignPat {\\n span: p.span,\\n left: Box::new(Pat::Ident(renamed.into())),\\n right: default_expr,\\n type_ann: None,\\n })),\\n None => Box::new(Pat::Ident(renamed.into())),\\n },\\n }\\n .into();\\n }\\n Err(_) => {}\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_prop(&mut self, prop: &mut Prop) {\\n match prop {\\n Prop::Shorthand(i) => {\\n let mut renamed = i.clone();\\n match self.rename_ident(&mut renamed) {\\n Ok(..) => {\\n *prop = Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(Ident {\\n // clear mark\\n span: i.span.with_ctxt(SyntaxContext::empty()),\\n ..i.clone()\\n }),\\n value: Box::new(Expr::Ident(renamed)),\\n })\\n }\\n Err(..) => {}\\n }\\n }\\n _ => prop.visit_mut_children_with(self),\\n }\\n }\\n\\n fn visit_mut_prop_name(&mut self, n: &mut PropName) {\\n match n {\\n PropName::Computed(c) => c.visit_mut_with(self),\\n _ => {}\\n }\\n }\\n}\\n\\nstruct VarFolder<'a, 'b> {\\n orig: &'a mut Operator<'b>,\\n renamed: &'a mut Vec,\\n}\\n\\nimpl VisitMut for VarFolder<'_, '_> {\\n noop_visit_mut_type!();\\n\\n #[inline]\\n fn visit_mut_expr(&mut self, _: &mut Expr) {}\\n\\n fn visit_mut_ident(&mut self, i: &mut Ident) {\\n let orig = i.clone();\\n match self.orig.rename_ident(i) {\\n Ok(..) => {\\n self.renamed\\n .push(ExportSpecifier::Named(ExportNamedSpecifier {\\n span: i.span,\\n exported: Some(orig),\\n orig: i.clone(),\\n is_type_only: false,\\n }));\\n }\\n Err(..) => {}\\n }\\n }\\n}\\n\\nimpl<'a> Operator<'a> {\\n /// Returns `Ok(renamed_ident)` if ident should be renamed.\\n fn rename_ident(&mut self, ident: &mut Ident) -> Result<(), ()> {\\n if let Some(sym) = self.0.rename.get(&ident.to_id()) {\\n ident.span = ident.span.with_ctxt(SyntaxContext::empty());\\n ident.sym = sym.clone();\\n return Ok(());\\n }\\n\\n Err(())\\n }\\n}\\n\",\n", + " 'content_id': '74d2abc1044566f841d78b5af41ebb3b259188f0',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 97,\n", + " 'path': '/ecmascript/transforms/base/src/hygiene/ops.rs',\n", + " 'size': 11038,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3933993028224446,\n", + " 'avg_line_length': 28.84228187919463,\n", + " 'blob_id': '15b7c1c6d188587681231ec9ef36ff750cf60476',\n", + " 'content': 'use rustc_hash::FxHashMap;\\nuse std::borrow::Cow;\\nuse swc_common::{\\n collections::AHashSet,\\n pass::{CompilerPass, Repeated},\\n util::take::Take,\\n Mark, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::ext::PatOrExprExt;\\nuse swc_ecma_utils::{\\n collect_decls, ident::IdentLike, ExprExt, Id, IsEmpty, ModuleItemLike, StmtLike, Value,\\n};\\nuse swc_ecma_visit::{\\n as_folder, noop_visit_mut_type, noop_visit_type, Fold, Node, Visit, VisitMut, VisitMutWith,\\n VisitWith,\\n};\\nuse tracing::{debug, span, trace, Level};\\n\\npub fn dce(config: Config) -> impl Fold + VisitMut + Repeated + CompilerPass {\\n as_folder(TreeShaker {\\n config,\\n changed: false,\\n pass: 0,\\n data: Default::default(),\\n })\\n}\\n\\n#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]\\npub struct Config {\\n /// If this [Mark] is applied to a function expression, it\\'s treated as a\\n /// separate module.\\n ///\\n /// **Note**: This is hack to make operation parallel while allowing invalid\\n /// module produced by the `swc_bundler`.\\n pub module_mark: Option,\\n}\\n\\nstruct TreeShaker {\\n config: Config,\\n changed: bool,\\n pass: u16,\\n data: Data,\\n}\\n\\nimpl CompilerPass for TreeShaker {\\n fn name() -> Cow<\\'static, str> {\\n Cow::Borrowed(\"tree-shaker\")\\n }\\n}\\n\\n#[derive(Default)]\\nstruct Data {\\n /// Bindings in the module.\\n bindings: AHashSet,\\n\\n used_names: FxHashMap,\\n}\\n#[derive(Debug, Default)]\\nstruct VarInfo {\\n /// This does not include self-references in a function.\\n pub usage: usize,\\n /// This does not include self-references in a function.\\n pub assign: usize,\\n}\\n\\nstruct Analyzer<\\'a> {\\n #[allow(dead_code)]\\n config: &\\'a Config,\\n in_var_decl: bool,\\n data: &\\'a mut Data,\\n cur_fn_id: Option,\\n}\\n\\nimpl Analyzer<\\'_> {\\n fn add(&mut self, id: Id, assign: bool) {\\n if let Some(f) = &self.cur_fn_id {\\n if id == *f {\\n return;\\n }\\n }\\n\\n if assign {\\n self.data.used_names.entry(id).or_default().assign += 1;\\n } else {\\n self.data.used_names.entry(id).or_default().usage += 1;\\n }\\n }\\n}\\n\\nimpl Visit for Analyzer<\\'_> {\\n noop_visit_type!();\\n\\n fn visit_assign_pat_prop(&mut self, n: &AssignPatProp, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n self.add(n.key.to_id(), true);\\n }\\n\\n fn visit_class_decl(&mut self, n: &ClassDecl, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if !n.class.decorators.is_empty() {\\n self.add(n.ident.to_id(), false);\\n }\\n }\\n\\n fn visit_class_expr(&mut self, n: &ClassExpr, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if !n.class.decorators.is_empty() {\\n if let Some(i) = &n.ident {\\n self.add(i.to_id(), false);\\n }\\n }\\n }\\n\\n fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier, _: &dyn Node) {\\n self.add(n.orig.to_id(), false);\\n }\\n\\n fn visit_expr(&mut self, e: &Expr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match e {\\n Expr::Ident(i) => {\\n self.add(i.to_id(), false);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_fn_decl(&mut self, n: &FnDecl, _: &dyn Node) {\\n let old = self.cur_fn_id.take();\\n self.cur_fn_id = Some(n.ident.to_id());\\n n.visit_children_with(self);\\n self.cur_fn_id = old;\\n\\n if !n.function.decorators.is_empty() {\\n self.add(n.ident.to_id(), false);\\n }\\n }\\n\\n fn visit_fn_expr(&mut self, n: &FnExpr, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if !n.function.decorators.is_empty() {\\n if let Some(i) = &n.ident {\\n self.add(i.to_id(), false);\\n }\\n }\\n }\\n\\n fn visit_pat(&mut self, p: &Pat, _: &dyn Node) {\\n p.visit_children_with(self);\\n\\n if !self.in_var_decl {\\n match p {\\n Pat::Ident(i) => {\\n self.add(i.id.to_id(), true);\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_prop(&mut self, p: &Prop, _: &dyn Node) {\\n p.visit_children_with(self);\\n\\n match p {\\n Prop::Shorthand(i) => {\\n self.add(i.to_id(), false);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_var_declarator(&mut self, v: &VarDeclarator, _: &dyn Node) {\\n let old = self.in_var_decl;\\n\\n self.in_var_decl = true;\\n v.name.visit_with(v, self);\\n\\n self.in_var_decl = false;\\n v.init.visit_with(v, self);\\n\\n self.in_var_decl = old;\\n }\\n}\\n\\nimpl Repeated for TreeShaker {\\n fn changed(&self) -> bool {\\n self.changed\\n }\\n\\n fn reset(&mut self) {\\n self.pass += 1;\\n self.changed = false;\\n self.data = Default::default();\\n }\\n}\\n\\nimpl TreeShaker {\\n fn visit_mut_stmt_likes(&mut self, stmts: &mut Vec)\\n where\\n T: StmtLike + ModuleItemLike,\\n Vec: VisitMutWith,\\n {\\n stmts.visit_mut_children_with(self);\\n\\n stmts.retain(|s| match s.as_stmt() {\\n Some(Stmt::Empty(..)) => false,\\n Some(Stmt::Block(s)) if s.is_empty() => {\\n debug!(\"Dropping an empty block statement\");\\n false\\n }\\n _ => true,\\n });\\n }\\n\\n fn can_drop_binding(&self, name: Id) -> bool {\\n !self.data.used_names.contains_key(&name)\\n }\\n\\n fn can_drop_assignment_to(&self, name: Id) -> bool {\\n self.data.bindings.contains(&name)\\n && self\\n .data\\n .used_names\\n .get(&name)\\n .map(|v| v.usage == 0)\\n .unwrap_or_default()\\n }\\n}\\n\\nimpl VisitMut for TreeShaker {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr) {\\n n.visit_mut_children_with(self);\\n\\n if !n.right.may_have_side_effects() {\\n if let Some(id) = n.left.as_ident() {\\n if self.can_drop_assignment_to(id.to_id()) {\\n self.changed = true;\\n debug!(\"Dropping an assignment to `{}` because it\\'s not used\", id);\\n\\n n.left.take();\\n return;\\n }\\n }\\n }\\n }\\n\\n fn visit_mut_decl(&mut self, n: &mut Decl) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n Decl::Fn(f) => {\\n if self.can_drop_binding(f.ident.to_id()) {\\n debug!(\"Dropping function `{}` as it\\'s not used\", f.ident);\\n self.changed = true;\\n\\n n.take();\\n return;\\n }\\n }\\n Decl::Class(c) => {\\n if self.can_drop_binding(c.ident.to_id()) {\\n debug!(\"Dropping class `{}` as it\\'s not used\", c.ident);\\n self.changed = true;\\n\\n n.take();\\n return;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n /// Noop.\\n fn visit_mut_export_decl(&mut self, _: &mut ExportDecl) {}\\n\\n /// Noop.\\n fn visit_mut_export_default_decl(&mut self, _: &mut ExportDefaultDecl) {}\\n\\n fn visit_mut_expr(&mut self, n: &mut Expr) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(callee),\\n args,\\n ..\\n }) => {\\n //\\n if args.is_empty() {\\n match &mut **callee {\\n Expr::Fn(FnExpr {\\n ident: None,\\n function:\\n Function {\\n is_async: false,\\n is_generator: false,\\n params,\\n body: Some(BlockStmt { stmts: body, .. }),\\n ..\\n },\\n }) => {\\n if params.is_empty() && body.len() == 1 {\\n match &mut body[0] {\\n Stmt::Return(ReturnStmt { arg: Some(arg), .. }) => match &**arg\\n {\\n Expr::Object(ObjectLit { props, .. }) => {\\n if props.iter().all(|p| match p {\\n PropOrSpread::Spread(_) => false,\\n PropOrSpread::Prop(p) => match &**p {\\n Prop::Shorthand(_) => true,\\n Prop::KeyValue(p) => p.value.is_ident(),\\n _ => false,\\n },\\n }) {\\n self.changed = true;\\n debug!(\"Dropping a wrapped esm\");\\n *n = *arg.take();\\n return;\\n }\\n }\\n\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n _ => {}\\n }\\n\\n match n {\\n Expr::Assign(a) => {\\n if match &a.left {\\n PatOrExpr::Expr(l) => l.is_invalid(),\\n PatOrExpr::Pat(l) => l.is_invalid(),\\n } {\\n *n = *a.right.take();\\n return;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_import_specifiers(&mut self, ss: &mut Vec) {\\n ss.retain(|s| {\\n let local = match s {\\n ImportSpecifier::Named(l) => &l.local,\\n ImportSpecifier::Default(l) => &l.local,\\n ImportSpecifier::Namespace(l) => &l.local,\\n };\\n\\n if self.can_drop_binding(local.to_id()) {\\n debug!(\\n \"Dropping import specifier `{}` because it\\'s not used\",\\n local\\n );\\n self.changed = true;\\n return false;\\n }\\n\\n true\\n });\\n }\\n\\n fn visit_mut_module(&mut self, m: &mut Module) {\\n let _tracing = span!(Level::ERROR, \"tree-shaker\", pass = self.pass).entered();\\n\\n self.data.bindings = collect_decls(&*m);\\n\\n {\\n let mut analyzer = Analyzer {\\n config: &self.config,\\n data: &mut self.data,\\n in_var_decl: false,\\n cur_fn_id: Default::default(),\\n };\\n m.visit_with(&Invalid { span: DUMMY_SP }, &mut analyzer);\\n }\\n trace!(\"Used = {:?}\", self.data.used_names);\\n\\n m.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_module_item(&mut self, n: &mut ModuleItem) {\\n match n {\\n ModuleItem::ModuleDecl(ModuleDecl::Import(i)) => {\\n let is_for_side_effect = i.specifiers.is_empty();\\n\\n i.visit_mut_with(self);\\n\\n if !is_for_side_effect && i.specifiers.is_empty() {\\n debug!(\"Dropping an import because it\\'s not used\");\\n self.changed = true;\\n *n = ModuleItem::Stmt(Stmt::Empty(EmptyStmt { span: DUMMY_SP }));\\n return;\\n }\\n }\\n _ => {\\n n.visit_mut_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_mut_module_items(&mut self, s: &mut Vec) {\\n self.visit_mut_stmt_likes(s);\\n }\\n\\n fn visit_mut_stmt(&mut self, s: &mut Stmt) {\\n s.visit_mut_children_with(self);\\n\\n match s {\\n Stmt::Decl(Decl::Var(v)) => {\\n let span = v.span;\\n let cnt = v.decls.len();\\n\\n // If all name is droppable, do so.\\n if cnt != 0\\n && v.decls.iter().all(|vd| match &vd.name {\\n Pat::Ident(i) => self.can_drop_binding(i.to_id()),\\n _ => false,\\n })\\n {\\n let exprs = v\\n .decls\\n .take()\\n .into_iter()\\n .filter_map(|v| v.init)\\n .collect::>();\\n\\n debug!(\\n count = cnt,\\n \"Dropping names of variables as they are not used\",\\n );\\n self.changed = true;\\n\\n if exprs.is_empty() {\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n } else {\\n if exprs.len() == 1 {\\n *s = Stmt::Expr(ExprStmt {\\n span,\\n expr: exprs.into_iter().next().unwrap(),\\n });\\n } else {\\n *s = Stmt::Expr(ExprStmt {\\n span,\\n expr: Box::new(Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs,\\n })),\\n });\\n }\\n }\\n }\\n }\\n\\n _ => {}\\n }\\n\\n match s {\\n Stmt::If(if_stmt) => {\\n if let Value::Known(v) = if_stmt.test.as_pure_bool() {\\n if v {\\n if if_stmt.alt.is_some() {\\n self.changed = true;\\n }\\n\\n if_stmt.alt = None;\\n debug!(\\n \"Dropping `alt` of an if statement because condition is always true\"\\n );\\n } else {\\n self.changed = true;\\n if let Some(alt) = if_stmt.alt.take() {\\n *s = *alt;\\n debug!(\\n \"Dropping `cons` of an if statement because condition is always \\\\\\n false\"\\n );\\n } else {\\n debug!(\"Dropping an if statement because condition is always false\");\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n }\\n return;\\n }\\n }\\n\\n if if_stmt.alt.is_empty() && if_stmt.cons.is_empty() {\\n if !if_stmt.test.may_have_side_effects() {\\n debug!(\"Dropping an if statement\");\\n self.changed = true;\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n }\\n }\\n }\\n _ => {}\\n }\\n\\n match s {\\n Stmt::Expr(es) => {\\n if match &*es.expr {\\n Expr::Lit(Lit::Str(..)) => false,\\n _ => !es.expr.may_have_side_effects(),\\n } {\\n debug!(\"Dropping an expression without side effect\");\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n self.changed = true;\\n return;\\n }\\n }\\n\\n Stmt::Decl(Decl::Var(v)) => {\\n if v.decls.is_empty() {\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_stmts(&mut self, s: &mut Vec) {\\n self.visit_mut_stmt_likes(s);\\n }\\n\\n fn visit_mut_var_decl_or_expr(&mut self, n: &mut VarDeclOrExpr) {\\n match n {\\n VarDeclOrExpr::VarDecl(..) => {}\\n VarDeclOrExpr::Expr(v) => {\\n v.visit_mut_with(self);\\n }\\n }\\n }\\n\\n fn visit_mut_var_decl_or_pat(&mut self, n: &mut VarDeclOrPat) {\\n match n {\\n VarDeclOrPat::VarDecl(..) => {}\\n VarDeclOrPat::Pat(v) => {\\n v.visit_mut_with(self);\\n }\\n }\\n }\\n\\n fn visit_mut_var_declarator(&mut self, v: &mut VarDeclarator) {\\n v.visit_mut_children_with(self);\\n\\n let can_drop = if let Some(init) = &v.init {\\n !init.may_have_side_effects()\\n } else {\\n true\\n };\\n\\n if can_drop {\\n match &v.name {\\n Pat::Ident(i) => {\\n if self.can_drop_binding(i.id.to_id()) {\\n self.changed = true;\\n debug!(\"Dropping {} because it\\'s not used\", i.id);\\n v.name.take();\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_mut_var_declarators(&mut self, n: &mut Vec) {\\n n.visit_mut_children_with(self);\\n\\n n.retain(|v| {\\n if v.name.is_invalid() {\\n return false;\\n }\\n\\n true\\n });\\n }\\n}\\n',\n", + " 'content_id': '761072f13b8d31e15de63e5448ee7fc5f05cf00e',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/transforms/optimization/src/simplify/dce/mod.rs',\n", + " 'size': 17786,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3764783180026281,\n", + " 'avg_line_length': 28.553398058252426,\n", + " 'blob_id': 'd6a6ba705dd6c8f46600bbda0279c28fc97c976a',\n", + " 'content': 'use super::Optimizer;\\nuse crate::mode::Mode;\\nuse rustc_hash::FxHashMap;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};\\n\\n/// Methods related to the option `collapse_vars`.\\nimpl Optimizer<\\'_, M>\\nwhere\\n M: Mode,\\n{\\n pub(super) fn collapse_assignment_to_vars(&mut self, e: &mut Expr) {\\n if !self.options.collapse_vars {\\n return;\\n }\\n\\n if self.ctx.in_try_block || self.ctx.executed_multiple_time || self.ctx.in_cond {\\n return;\\n }\\n\\n match &*e {\\n Expr::Assign(assign) => {\\n //\\n let left = match &assign.left {\\n PatOrExpr::Expr(_) => return,\\n PatOrExpr::Pat(left) => match &**left {\\n Pat::Ident(i) => i,\\n _ => return,\\n },\\n };\\n\\n if let Some(usage) = self\\n .data\\n .as_ref()\\n .and_then(|data| data.vars.get(&left.to_id()))\\n {\\n if !usage.declared\\n || !usage.is_fn_local\\n || usage.assign_count != 1\\n || usage.var_kind == Some(VarDeclKind::Const)\\n {\\n return;\\n }\\n\\n if usage.used_in_loop {\\n match &*assign.right {\\n Expr::Lit(..) | Expr::Ident(..) => {}\\n _ => return,\\n }\\n }\\n\\n if usage.usage_count >= 2 {\\n match &*assign.right {\\n Expr::Lit(..) => {}\\n _ => return,\\n }\\n }\\n }\\n\\n let value = match &*assign.right {\\n Expr::Lit(..)\\n | Expr::Member(MemberExpr {\\n computed: false, ..\\n }) => assign.right.clone(),\\n _ => return,\\n };\\n\\n tracing::debug!(\\n \"collpase_vars: Decided to inline {}{:?}\",\\n left.id.sym,\\n left.id.span.ctxt\\n );\\n\\n self.lits.insert(left.to_id(), value);\\n }\\n _ => {}\\n }\\n }\\n}\\n\\nstruct Inliner<\\'a> {\\n values: &\\'a mut FxHashMap>>,\\n}\\n\\nimpl VisitMut for Inliner<\\'_> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n e.visit_mut_children_with(self);\\n\\n match e {\\n Expr::Ident(i) => {\\n if let Some(value) = self.values.remove(&i.to_id()) {\\n tracing::debug!(\"collapse_vars: Inlining {}{:?}\", i.sym, i.span.ctxt);\\n\\n *e = *value.expect(\"should be used only once\");\\n }\\n }\\n _ => {}\\n }\\n }\\n}\\n',\n", + " 'content_id': '4461351400553a3e0414bdcad5588e8aa4ef7fbd',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 90,\n", + " 'path': '/ecmascript/minifier/src/compress/optimize/collapse_vars.rs',\n", + " 'size': 3044,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6264975334742776,\n", + " 'avg_line_length': 31.25,\n", + " 'blob_id': '94396c1967f7129fbf57b809664483aae94c2c33',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\nbuild = \"build.rs\"\\ndescription = \"Speedy web compiler\"\\ndocumentation = \"https://rustdoc.swc.rs/swc/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_node_bundler\"\\npublish = false\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.0.0\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nanyhow = \"1\"\\ndashmap = \"4.0.2\"\\nis-macro = \"0.1.8\"\\nonce_cell = \"1\"\\nregex = \"1\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1\", features = [\"derive\"]}\\nserde_json = \"1\"\\nstring_enum = {version = \"0.3\", path = \"../../macros/string_enum\"}\\nswc = {path = \"../../\"}\\nswc_atoms = {path = \"../../atoms\"}\\nswc_bundler = {path = \"../../bundler\", features = [\"concurrent\"]}\\nswc_common = {path = \"../../common\", features = [\"concurrent\"]}\\nswc_ecma_ast = {path = \"../../ecmascript/ast\"}\\nswc_ecma_codegen = {path = \"../../ecmascript/codegen\"}\\nswc_ecma_loader = {path = \"../../ecmascript/loader\"}\\nswc_ecma_parser = {path = \"../../ecmascript/parser\"}\\nswc_ecma_transforms = {path = \"../../ecmascript/transforms\"}\\nswc_ecma_utils = {path = \"../../ecmascript/utils\"}\\nswc_ecma_visit = {path = \"../../ecmascript/visit\"}\\nswc_node_base = {path = \"../../node/base\"}\\ntracing = \"0.1.28\"\\n\\n[dev-dependencies]\\npretty_assertions = \"0.6.1\"\\npretty_env_logger = \"0.3\"\\ntempfile = \"3\"\\ntesting = {path = \"../../testing\"}\\nwalkdir = \"2.3.1\"\\n',\n", + " 'content_id': 'e79a4c8d5ab6b00c9125aa43b3263d22cab37af6',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/node/bundler/Cargo.toml',\n", + " 'size': 1419,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4102260972365893,\n", + " 'avg_line_length': 25.74703557312253,\n", + " 'blob_id': 'f4da83f9fa143c8acafe6c7c3dd3feb8563ad2f8',\n", + " 'content': 'use crate::{\\n compress::{compressor, pure_optimizer},\\n marks::Marks,\\n mode::Mode,\\n};\\nuse rustc_hash::FxHashMap;\\nuse std::sync::{Arc, Mutex};\\nuse swc_atoms::js_word;\\nuse swc_common::{util::take::Take, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms::optimization::simplify::{expr_simplifier, ExprSimplifierConfig};\\nuse swc_ecma_utils::{ident::IdentLike, undefined, ExprExt, ExprFactory, Id};\\nuse swc_ecma_visit::{FoldWith, VisitMutWith};\\n\\npub struct Evaluator {\\n module: Module,\\n marks: Marks,\\n data: Eval,\\n /// We run minification only once.\\n done: bool,\\n}\\n\\nimpl Evaluator {\\n pub fn new(module: Module, marks: Marks) -> Self {\\n Evaluator {\\n module,\\n marks,\\n data: Default::default(),\\n done: Default::default(),\\n }\\n }\\n}\\n\\n#[derive(Default, Clone)]\\nstruct Eval {\\n store: Arc>,\\n}\\n\\n#[derive(Default)]\\nstruct EvalStore {\\n cache: FxHashMap>,\\n}\\n\\n#[derive(Debug, Clone, PartialEq)]\\npub enum EvalResult {\\n Lit(Lit),\\n Undefined,\\n}\\n\\nimpl Mode for Eval {\\n fn store(&self, id: Id, value: &Expr) {\\n let mut w = self.store.lock().unwrap();\\n w.cache.insert(id, Box::new(value.clone()));\\n }\\n\\n fn force_str_for_tpl() -> bool {\\n true\\n }\\n}\\n\\nimpl Evaluator {\\n fn run(&mut self) {\\n if !self.done {\\n self.done = true;\\n\\n let marks = self.marks;\\n let data = self.data.clone();\\n self.module.map_with_mut(|m| {\\n //\\n swc_common::GLOBALS.with(|globals| {\\n //\\n m.fold_with(&mut compressor(\\n &globals,\\n marks,\\n &serde_json::from_str(\"{}\").unwrap(),\\n &data,\\n ))\\n })\\n });\\n }\\n }\\n\\n pub fn eval(&mut self, e: &Expr) -> Option {\\n match e {\\n Expr::Seq(s) => return self.eval(s.exprs.last()?),\\n\\n Expr::Lit(l @ Lit::Null(..))\\n | Expr::Lit(l @ Lit::Num(..) | l @ Lit::Str(..) | l @ Lit::BigInt(..)) => {\\n return Some(EvalResult::Lit(l.clone()))\\n }\\n\\n Expr::Tpl(t) => {\\n return self.eval_tpl(&t);\\n }\\n\\n Expr::TaggedTpl(t) => {\\n // Handle `String.raw`\\n\\n match &*t.tag {\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(tag_obj),\\n prop,\\n computed: false,\\n ..\\n }) if tag_obj.is_ident_ref_to(\"String\".into())\\n && prop.is_ident_ref_to(\"raw\".into()) =>\\n {\\n return self.eval_tpl(&t.tpl);\\n }\\n\\n _ => {}\\n }\\n }\\n\\n Expr::Cond(c) => {\\n let test = self.eval(&c.test)?;\\n\\n if is_truthy(&test)? {\\n return self.eval(&c.cons);\\n } else {\\n return self.eval(&c.alt);\\n }\\n }\\n\\n // TypeCastExpression, ExpressionStatement etc\\n Expr::TsTypeAssertion(e) => {\\n return self.eval(&e.expr);\\n }\\n\\n Expr::TsConstAssertion(e) => {\\n return self.eval(&e.expr);\\n }\\n\\n // \"foo\".length\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n prop,\\n computed: false,\\n ..\\n }) if obj.is_lit() && prop.is_ident_ref_to(\"length\".into()) => {}\\n\\n Expr::Unary(UnaryExpr {\\n op: op!(\"void\"), ..\\n }) => return Some(EvalResult::Undefined),\\n\\n Expr::Unary(UnaryExpr {\\n op: op!(\"!\"), arg, ..\\n }) => {\\n let arg = self.eval(&arg)?;\\n\\n if is_truthy(&arg)? {\\n return Some(EvalResult::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: false,\\n })));\\n } else {\\n return Some(EvalResult::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n })));\\n }\\n }\\n\\n _ => {}\\n }\\n\\n Some(EvalResult::Lit(self.eval_as_expr(e)?.lit()?))\\n }\\n\\n fn eval_as_expr(&mut self, e: &Expr) -> Option> {\\n match e {\\n Expr::Ident(i) => {\\n self.run();\\n\\n let lock = self.data.store.lock().ok()?;\\n let val = lock.cache.get(&i.to_id())?;\\n\\n return Some(val.clone());\\n }\\n\\n Expr::Member(MemberExpr {\\n span,\\n obj: ExprOrSuper::Expr(obj),\\n prop,\\n computed: false,\\n ..\\n }) => {\\n let obj = self.eval_as_expr(&obj)?;\\n\\n let mut e = Expr::Member(MemberExpr {\\n span: *span,\\n obj: obj.as_obj(),\\n prop: prop.clone(),\\n computed: false,\\n });\\n\\n e.visit_mut_with(&mut expr_simplifier(ExprSimplifierConfig {\\n preserve_string_call: true,\\n }));\\n return Some(Box::new(e));\\n }\\n\\n _ => {}\\n }\\n\\n None\\n }\\n\\n pub fn eval_tpl(&mut self, q: &Tpl) -> Option {\\n self.run();\\n\\n let mut exprs = vec![];\\n\\n for expr in &q.exprs {\\n let res = self.eval(expr)?;\\n exprs.push(match res {\\n EvalResult::Lit(v) => Box::new(Expr::Lit(v)),\\n EvalResult::Undefined => undefined(DUMMY_SP),\\n });\\n }\\n\\n let mut e = Expr::Tpl(Tpl {\\n span: q.span,\\n exprs,\\n quasis: q.quasis.clone(),\\n });\\n\\n {\\n let data = self.data.clone();\\n e.visit_mut_with(&mut pure_optimizer(\\n &serde_json::from_str(\"{}\").unwrap(),\\n self.marks,\\n &data,\\n false,\\n ));\\n }\\n\\n Some(EvalResult::Lit(e.lit()?))\\n }\\n}\\n\\nfn is_truthy(lit: &EvalResult) -> Option {\\n match lit {\\n EvalResult::Lit(v) => match v {\\n Lit::Str(v) => Some(v.value != js_word!(\"\")),\\n Lit::Bool(v) => Some(v.value),\\n Lit::Null(_) => Some(false),\\n Lit::Num(v) => Some(v.value != 0.0 && v.value != -0.0),\\n _ => None,\\n },\\n EvalResult::Undefined => Some(false),\\n }\\n}\\n',\n", + " 'content_id': 'a6117dfe7455397ca4472257f300b47e7b053b8c',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 89,\n", + " 'path': '/ecmascript/minifier/src/eval.rs',\n", + " 'size': 6767,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5146487822096717,\n", + " 'avg_line_length': 21.664,\n", + " 'blob_id': '2815a9dfa68ef5d4d1e7ec968be380f0050f59a0',\n", + " 'content': 'use fxhash::{FxHashMap, FxHashSet};\\nuse std::cell::RefCell;\\nuse swc_atoms::JsWord;\\nuse swc_common::{SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_visit::{noop_visit_type, Node, Visit, VisitWith};\\n\\n#[derive(Default)]\\npub(super) struct All {\\n pub scopes: FxHashMap,\\n}\\n\\npub(super) fn analyze(node: &N) -> All\\nwhere\\n N: for<\\'aa> VisitWith>,\\n{\\n let mut data = All::default();\\n let mut v = VarAnalyzer {\\n all: &mut data,\\n cur: Default::default(),\\n };\\n node.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n\\n data\\n}\\n\\n#[derive(Debug, Default)]\\npub(super) struct VarHygieneData {\\n pub decls: FxHashMap>,\\n}\\n\\n#[derive(Default)]\\nstruct Scope<\\'a> {\\n parent: Option<&\\'a Scope<\\'a>>,\\n\\n data: RefCell,\\n}\\n\\nimpl<\\'a> Scope<\\'a> {\\n pub fn new(parent: Option<&\\'a Scope<\\'a>>) -> Self {\\n Scope {\\n parent,\\n data: Default::default(),\\n }\\n }\\n\\n /// Add usage or declaration of a variable\\n fn add(&mut self, i: &Ident) {\\n let mut cur = Some(&*self);\\n\\n while let Some(scope) = cur {\\n let mut w = scope.data.borrow_mut();\\n w.decls\\n .entry(i.sym.clone())\\n .or_default()\\n .insert(i.span.ctxt);\\n\\n cur = scope.parent;\\n }\\n }\\n}\\n\\npub struct VarAnalyzer<\\'a> {\\n all: &\\'a mut All,\\n cur: Scope<\\'a>,\\n}\\n\\nmacro_rules! scoped {\\n ($v:expr, $n:expr) => {\\n let data = {\\n let child = Scope::new(Some(&$v.cur));\\n let mut v = VarAnalyzer {\\n all: &mut $v.all,\\n cur: child,\\n };\\n\\n $n.visit_children_with(&mut v);\\n\\n v.cur.data.into_inner()\\n };\\n\\n let old = $v.all.scopes.insert($n.span.ctxt, data);\\n debug_assert!(old.is_none(), \"{:?}\", $n.span.ctxt);\\n };\\n}\\n\\nimpl Visit for VarAnalyzer<\\'_> {\\n noop_visit_type!();\\n\\n fn visit_arrow_expr(&mut self, n: &ArrowExpr, _: &dyn Node) {\\n scoped!(self, n);\\n }\\n\\n fn visit_block_stmt(&mut self, n: &BlockStmt, _: &dyn Node) {\\n scoped!(self, n);\\n }\\n\\n fn visit_function(&mut self, n: &Function, _: &dyn Node) {\\n scoped!(self, n);\\n }\\n\\n fn visit_ident(&mut self, i: &Ident, _: &dyn Node) {\\n tracing::trace!(\"hygiene/vars: Found {}\", i);\\n\\n self.cur.add(i);\\n }\\n\\n fn visit_member_expr(&mut self, n: &MemberExpr, _: &dyn Node) {\\n n.obj.visit_with(n, self);\\n\\n if n.computed {\\n n.prop.visit_with(n, self);\\n }\\n }\\n\\n fn visit_prop_name(&mut self, n: &PropName, _: &dyn Node) {\\n match n {\\n PropName::Computed(_) => {\\n n.visit_children_with(self);\\n }\\n\\n _ => {}\\n }\\n }\\n}\\n',\n", + " 'content_id': 'b4355ce987d4237ad59749bb59a3265f71d2eec5',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 67,\n", + " 'path': '/ecmascript/minifier/src/pass/hygiene/vars.rs',\n", + " 'size': 2833,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6537966537966537,\n", + " 'avg_line_length': 34.31818181818182,\n", + " 'blob_id': 'e50529de53a0508b8b026d670b4950e069df3fa7',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Base for swc plugins\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_plugin/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_plugin\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.6.0\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nabi_stable = \"0.10.2\"\\nanyhow = \"1.0.41\"\\nserde = \"1.0.126\"\\nserde_json = \"1.0.64\"\\nswc_atoms = {version = \"0.2.7\", path = \"../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ecmascript/ast\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../ecmascript/utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../ecmascript/visit\"}\\n',\n", + " 'content_id': '122351cee0ed1f7a64ab4248c2114094083c4dee',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/plugin/Cargo.toml',\n", + " 'size': 777,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6441717791411042,\n", + " 'avg_line_length': 32.958333333333336,\n", + " 'blob_id': 'a4e95b8436000e732761e8fdacca43daf1c12bc9',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Utilities for swc ecmascript ast nodes\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_utils/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_utils\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.46.2\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nonce_cell = \"1\"\\nrayon = { version = \"1.5.1\", optional = true }\\nscoped-tls = \"1\"\\nswc_atoms = {version = \"0.2.0\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../visit\"}\\nunicode-xid = \"0.2\"\\n\\n[dev-dependencies]\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\n',\n", + " 'content_id': '86d2a4e2aaa38342f6a2badfbbbec25fa1384855',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/utils/Cargo.toml',\n", + " 'size': 815,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3592322811885767,\n", + " 'avg_line_length': 34.44672131147541,\n", + " 'blob_id': 'd52a00619e61b81e08d0380636589ded59668097',\n", + " 'content': '//! Parser for object literal.\\n\\nuse super::*;\\nuse crate::{lexer::TokenContext, parser::class_and_fn::is_not_this, token::Keyword};\\nuse swc_atoms::js_word;\\nuse swc_common::Spanned;\\n\\nimpl<\\'a, I: Tokens> Parser {\\n /// Parse a object literal or object pattern.\\n pub(super) fn parse_object(&mut self) -> PResult\\n where\\n Self: ParseObject,\\n {\\n let ctx = Context {\\n is_direct_child_of_cond: false,\\n dont_parse_colon_as_type_ann: false,\\n ..self.ctx()\\n };\\n self.with_ctx(ctx).parse_with(|p| {\\n trace_cur!(p, parse_object);\\n\\n let start = cur_pos!(p);\\n assert_and_bump!(p, \\'{\\');\\n\\n let mut props = vec![];\\n\\n let mut first = true;\\n while !eat!(p, \\'}\\') {\\n // Handle comma\\n if first {\\n first = false;\\n } else {\\n expect!(p, \\',\\');\\n if eat!(p, \\'}\\') {\\n break;\\n }\\n }\\n\\n let prop = p.parse_object_prop()?;\\n props.push(prop);\\n }\\n\\n p.make_object(span!(p, start), props)\\n })\\n }\\n\\n /// spec: \\'PropertyName\\'\\n pub(super) fn parse_prop_name(&mut self) -> PResult {\\n trace_cur!(self, parse_prop_name);\\n\\n let ctx = self.ctx();\\n self.with_ctx(Context {\\n in_property_name: true,\\n ..ctx\\n })\\n .parse_with(|p| {\\n let start = cur_pos!(p);\\n\\n let v = match *cur!(p, true)? {\\n Token::Str { .. } => match bump!(p) {\\n Token::Str { value, has_escape } => PropName::Str(Str {\\n span: span!(p, start),\\n value,\\n has_escape,\\n kind: StrKind::Normal {\\n contains_quote: true,\\n },\\n }),\\n _ => unreachable!(),\\n },\\n Token::Num(_) => match bump!(p) {\\n Token::Num(value) => PropName::Num(Number {\\n span: span!(p, start),\\n value,\\n }),\\n _ => unreachable!(),\\n },\\n Token::BigInt(_) => match bump!(p) {\\n Token::BigInt(value) => PropName::BigInt(BigInt {\\n span: span!(p, start),\\n value,\\n }),\\n _ => unreachable!(),\\n },\\n Word(..) => match bump!(p) {\\n Word(w) => {\\n match w {\\n Word::Keyword(Keyword::Function) => {\\n // See https://github.com/swc-project/swc/issues/2075\\n let ctx = p.input.token_context_mut();\\n let token_ctx = ctx.pop();\\n\\n debug_assert_eq!(token_ctx, Some(TokenContext::FnExpr));\\n }\\n _ => {}\\n }\\n PropName::Ident(Ident::new(w.into(), span!(p, start)))\\n }\\n _ => unreachable!(),\\n },\\n tok!(\\'[\\') => {\\n bump!(p);\\n let inner_start = cur_pos!(p);\\n\\n let mut expr = p.include_in_expr(true).parse_assignment_expr()?;\\n\\n if p.syntax().typescript() && is!(p, \\',\\') {\\n let mut exprs = vec![expr];\\n\\n while eat!(p, \\',\\') {\\n exprs.push(p.include_in_expr(true).parse_assignment_expr()?);\\n }\\n\\n p.emit_err(span!(p, inner_start), SyntaxError::TS1171);\\n\\n expr = Box::new(\\n SeqExpr {\\n span: span!(p, inner_start),\\n exprs,\\n }\\n .into(),\\n );\\n }\\n\\n expect!(p, \\']\\');\\n\\n PropName::Computed(ComputedPropName {\\n span: span!(p, start),\\n expr,\\n })\\n }\\n _ => unexpected!(\\n p,\\n \"identifier, string literal, numeric literal or [ for the computed key\"\\n ),\\n };\\n\\n Ok(v)\\n })\\n }\\n}\\n\\nimpl ParseObject> for Parser {\\n type Prop = PropOrSpread;\\n\\n fn make_object(&mut self, span: Span, props: Vec) -> PResult> {\\n Ok(Box::new(Expr::Object(ObjectLit { span, props })))\\n }\\n\\n /// spec: \\'PropertyDefinition\\'\\n fn parse_object_prop(&mut self) -> PResult {\\n trace_cur!(self, parse_object_prop);\\n\\n let start = cur_pos!(self);\\n // Parse as \\'MethodDefinition\\'\\n\\n if eat!(self, \"...\") {\\n // spread element\\n let dot3_token = span!(self, start);\\n\\n let expr = self.include_in_expr(true).parse_assignment_expr()?;\\n\\n return Ok(PropOrSpread::Spread(SpreadElement { dot3_token, expr }));\\n }\\n\\n if eat!(self, \\'*\\') {\\n let span_of_gen = span!(self, start);\\n\\n let name = self.parse_prop_name()?;\\n return self\\n .parse_fn_args_body(\\n // no decorator in an object literal\\n vec![],\\n start,\\n |p| p.parse_unique_formal_params(),\\n false,\\n true,\\n )\\n .map(|function| {\\n PropOrSpread::Prop(Box::new(Prop::Method(MethodProp {\\n key: name,\\n function,\\n })))\\n });\\n }\\n\\n let has_modifiers = self.eat_any_ts_modifier()?;\\n let modifiers_span = self.input.prev_span();\\n\\n let key = self.parse_prop_name()?;\\n\\n if self.input.syntax().typescript()\\n && !is_one_of!(self, \\'(\\', \\'[\\', \\':\\', \\',\\', \\'?\\', \\'=\\', \\'*\\', IdentName, Str, Num)\\n && !(self.input.syntax().typescript() && is!(self, \\'<\\'))\\n && !(is!(self, \\'}\\')\\n && match key {\\n PropName::Ident(..) => true,\\n _ => false,\\n })\\n {\\n trace_cur!(self, parse_object_prop_error);\\n\\n self.emit_err(self.input.cur_span(), SyntaxError::TS1005);\\n return Ok(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key,\\n value: Box::new(Expr::Invalid(Invalid {\\n span: span!(self, start),\\n })),\\n }))));\\n }\\n //\\n // {[computed()]: a,}\\n // { \\'a\\': a, }\\n // { 0: 1, }\\n // { a: expr, }\\n if eat!(self, \\':\\') {\\n let value = self.include_in_expr(true).parse_assignment_expr()?;\\n return Ok(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key,\\n value,\\n }))));\\n }\\n\\n // Handle `a(){}` (and async(){} / get(){} / set(){})\\n if (self.input.syntax().typescript() && is!(self, \\'<\\')) || is!(self, \\'(\\') {\\n return self\\n .parse_fn_args_body(\\n // no decorator in an object literal\\n vec![],\\n start,\\n |p| p.parse_unique_formal_params(),\\n false,\\n false,\\n )\\n .map(|function| Box::new(Prop::Method(MethodProp { key, function })))\\n .map(PropOrSpread::Prop);\\n }\\n\\n let ident = match key {\\n PropName::Ident(ident) => ident,\\n // TODO\\n _ => unexpected!(self, \"identifier\"),\\n };\\n\\n if eat!(self, \\'?\\') {\\n self.emit_err(self.input.prev_span(), SyntaxError::TS1162);\\n }\\n\\n // `ident` from parse_prop_name is parsed as \\'IdentifierName\\'\\n // It means we should check for invalid expressions like { for, }\\n if is_one_of!(self, \\'=\\', \\',\\', \\'}\\') {\\n let is_reserved_word = { self.ctx().is_reserved_word(&ident.sym) };\\n if is_reserved_word {\\n self.emit_err(ident.span, SyntaxError::ReservedWordInObjShorthandOrPat);\\n }\\n\\n if eat!(self, \\'=\\') {\\n let value = self.include_in_expr(true).parse_assignment_expr()?;\\n return Ok(PropOrSpread::Prop(Box::new(Prop::Assign(AssignProp {\\n key: ident,\\n value,\\n }))));\\n }\\n\\n return Ok(PropOrSpread::Prop(Box::new(Prop::from(ident))));\\n }\\n\\n // get a(){}\\n // set a(v){}\\n // async a(){}\\n\\n match ident.sym {\\n js_word!(\"get\") | js_word!(\"set\") | js_word!(\"async\") => {\\n trace_cur!(self, parse_object_prop__after_accessor);\\n\\n if has_modifiers {\\n self.emit_err(modifiers_span, SyntaxError::TS1042);\\n }\\n\\n let is_generator = ident.sym == js_word!(\"async\") && eat!(self, \\'*\\');\\n let key = self.parse_prop_name()?;\\n let key_span = key.span();\\n\\n match ident.sym {\\n js_word!(\"get\") => self\\n .parse_fn_args_body(\\n // no decorator in an object literal\\n vec![],\\n start,\\n |p| {\\n let params = p.parse_formal_params()?;\\n\\n if params.iter().filter(|p| is_not_this(p)).count() != 0 {\\n p.emit_err(key_span, SyntaxError::TS1094);\\n }\\n\\n Ok(params)\\n },\\n false,\\n false,\\n )\\n .map(\\n |Function {\\n body,\\n type_params,\\n return_type,\\n ..\\n }| {\\n if type_params.is_some() {\\n self.emit_err(type_params.unwrap().span(), SyntaxError::TS1094);\\n }\\n\\n if self.input.syntax().typescript()\\n && self.input.target() == JscTarget::Es3\\n {\\n self.emit_err(key_span, SyntaxError::TS1056);\\n }\\n\\n PropOrSpread::Prop(Box::new(Prop::Getter(GetterProp {\\n span: span!(self, start),\\n key,\\n type_ann: return_type,\\n body,\\n })))\\n },\\n ),\\n js_word!(\"set\") => self\\n .parse_fn_args_body(\\n // no decorator in an object literal\\n vec![],\\n start,\\n |p| {\\n let params = p.parse_formal_params()?;\\n\\n if params.iter().filter(|p| is_not_this(p)).count() != 1 {\\n p.emit_err(key_span, SyntaxError::TS1094);\\n }\\n\\n if !params.is_empty() {\\n if let Pat::Rest(..) = params[0].pat {\\n p.emit_err(params[0].span(), SyntaxError::RestPatInSetter);\\n }\\n }\\n\\n if p.input.syntax().typescript()\\n && p.input.target() == JscTarget::Es3\\n {\\n p.emit_err(key_span, SyntaxError::TS1056);\\n }\\n\\n Ok(params)\\n },\\n false,\\n false,\\n )\\n .map(\\n |Function {\\n params,\\n body,\\n type_params,\\n ..\\n }| {\\n if type_params.is_some() {\\n self.emit_err(type_params.unwrap().span(), SyntaxError::TS1094);\\n }\\n\\n // debug_assert_eq!(params.len(), 1);\\n PropOrSpread::Prop(Box::new(Prop::Setter(SetterProp {\\n span: span!(self, start),\\n key,\\n body,\\n param: params.into_iter().map(|p| p.pat).next().unwrap_or_else(\\n || Pat::Invalid(Invalid { span: key_span }),\\n ),\\n })))\\n },\\n ),\\n js_word!(\"async\") => self\\n .parse_fn_args_body(\\n // no decorator in an object literal\\n vec![],\\n start,\\n |p| p.parse_unique_formal_params(),\\n true,\\n is_generator,\\n )\\n .map(|function| {\\n PropOrSpread::Prop(Box::new(Prop::Method(MethodProp { key, function })))\\n }),\\n _ => unreachable!(),\\n }\\n }\\n _ => {\\n if self.input.syntax().typescript() {\\n unexpected!(\\n self,\\n \"... , *, (, [, :, , ?, =, an identifier, public, protected, private, \\\\\\n readonly, <.\"\\n )\\n } else {\\n unexpected!(self, \"... , *, (, [, :, , ?, = or an identifier\")\\n }\\n }\\n }\\n }\\n}\\n\\nimpl ParseObject for Parser {\\n type Prop = ObjectPatProp;\\n\\n fn make_object(&mut self, span: Span, props: Vec) -> PResult {\\n let len = props.len();\\n for (i, p) in props.iter().enumerate() {\\n if i == len - 1 {\\n if let ObjectPatProp::Rest(ref rest) = p {\\n match *rest.arg {\\n Pat::Ident(..) => {}\\n _ => syntax_error!(self, p.span(), SyntaxError::DotsWithoutIdentifier),\\n }\\n }\\n continue;\\n }\\n\\n if let ObjectPatProp::Rest(..) = p {\\n if self.syntax().early_errors() {\\n syntax_error!(self, p.span(), SyntaxError::NonLastRestParam)\\n }\\n }\\n }\\n\\n let optional = (self.input.syntax().dts() || self.ctx().in_declare) && eat!(self, \\'?\\');\\n\\n Ok(Pat::Object(ObjectPat {\\n span,\\n props,\\n optional,\\n type_ann: None,\\n }))\\n }\\n\\n /// Production \\'BindingProperty\\'\\n fn parse_object_prop(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n if eat!(self, \"...\") {\\n // spread element\\n let dot3_token = span!(self, start);\\n\\n let arg = Box::new(self.parse_binding_pat_or_ident()?);\\n\\n return Ok(ObjectPatProp::Rest(RestPat {\\n span: span!(self, start),\\n dot3_token,\\n arg,\\n type_ann: None,\\n }));\\n }\\n\\n let key = self.parse_prop_name()?;\\n if eat!(self, \\':\\') {\\n let value = Box::new(self.parse_binding_element()?);\\n\\n return Ok(ObjectPatProp::KeyValue(KeyValuePatProp { key, value }));\\n }\\n let key = match key {\\n PropName::Ident(ident) => ident,\\n _ => unexpected!(self, \"an identifier\"),\\n };\\n\\n let value = if eat!(self, \\'=\\') {\\n self.include_in_expr(true)\\n .parse_assignment_expr()\\n .map(Some)?\\n } else {\\n if self.ctx().is_reserved_word(&key.sym) {\\n self.emit_err(key.span, SyntaxError::ReservedWordInObjShorthandOrPat);\\n }\\n\\n None\\n };\\n\\n Ok(ObjectPatProp::Assign(AssignPatProp {\\n span: span!(self, start),\\n key,\\n value,\\n }))\\n }\\n}\\n',\n", + " 'content_id': 'e073e8d3dc46e75ee89dc5861d7aa1089bd8534f',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/parser/src/parser/object.rs',\n", + " 'size': 17298,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6012396694214877,\n", + " 'avg_line_length': 36.23076923076923,\n", + " 'blob_id': '790dad9bfd453f2f96da5b56b753ddab343dd4cb',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_base/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_base\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.35.0\"\\n\\n[dependencies]\\nonce_cell = \"1.5.2\"\\nphf = {version = \"0.8.0\", features = [\"macros\"]}\\nrustc-hash = \"1.1.0\"\\nscoped-tls = \"1.0.0\"\\nsmallvec = \"1.6.0\"\\nswc_atoms = {version = \"0.2\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\n\\n[dev-dependencies]\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../../codegen\"}\\ntesting = {version = \"0.14.0\", path = \"../../../testing\"}\\n',\n", + " 'content_id': 'b8fd81f6be101b46d7f24a707c0844548e8d71f8',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 66,\n", + " 'path': '/ecmascript/transforms/base/Cargo.toml',\n", + " 'size': 968,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5447216890595009,\n", + " 'avg_line_length': 32.22704081632653,\n", + " 'blob_id': 'ef74159498a847f7236e1149ce26b08b72ed9247',\n", + " 'content': '// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\\n// file at the top-level directory of this distribution and at\\n// http://rust-lang.org/COPYRIGHT.\\n//\\n// Licensed under the Apache License, Version 2.0 or the MIT license\\n// , at your\\n// option. This file may not be copied, modified, or distributed\\n// except according to those terms.\\n\\n//! Machinery for hygienic macros, inspired by the `MTWT[1]` paper.\\n//!\\n//! `[1]` Matthew Flatt, Ryan Culpepper, David Darais, and Robert Bruce Findler.\\n//! 2012. *Macros that work together: Compile-time bindings, partial expansion,\\n//! and definition contexts*. J. Funct. Program. 22, 2 (March 2012), 181-216.\\n//! DOI=10.1017/S0956796812000093 \\n\\nuse super::GLOBALS;\\nuse rustc_hash::FxHashMap;\\nuse serde::{Deserialize, Serialize};\\nuse std::{\\n collections::{HashMap, HashSet},\\n fmt,\\n};\\n\\n/// A SyntaxContext represents a chain of macro expansions (represented by\\n/// marks).\\n#[derive(Clone, Copy, PartialEq, Eq, Default, PartialOrd, Ord, Hash, Serialize, Deserialize)]\\n#[serde(transparent)]\\npub struct SyntaxContext(u32);\\n\\n#[cfg(feature = \"arbitrary\")]\\nimpl<\\'a> arbitrary::Arbitrary<\\'a> for SyntaxContext {\\n fn arbitrary(_: &mut arbitrary::Unstructured<\\'_>) -> arbitrary::Result {\\n Ok(SyntaxContext::empty())\\n }\\n}\\n\\n#[derive(Copy, Clone, Debug)]\\nstruct SyntaxContextData {\\n outer_mark: Mark,\\n prev_ctxt: SyntaxContext,\\n // This context, but with all transparent and semi-transparent marks filtered away.\\n opaque: SyntaxContext,\\n // This context, but with all transparent marks filtered away.\\n opaque_and_semitransparent: SyntaxContext,\\n}\\n\\n/// A mark is a unique id associated with a macro expansion.\\n#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]\\npub struct Mark(u32);\\n\\n#[derive(Clone, Debug)]\\nstruct MarkData {\\n parent: Mark,\\n is_builtin: bool,\\n}\\n\\nimpl Mark {\\n pub fn fresh(parent: Mark) -> Self {\\n HygieneData::with(|data| {\\n data.marks.push(MarkData {\\n parent,\\n is_builtin: false,\\n });\\n Mark(data.marks.len() as u32 - 1)\\n })\\n }\\n\\n /// The mark of the theoretical expansion that generates freshly parsed,\\n /// unexpanded AST.\\n #[inline]\\n pub fn root() -> Self {\\n Mark(0)\\n }\\n\\n #[inline]\\n pub fn as_u32(self) -> u32 {\\n self.0\\n }\\n\\n #[inline]\\n pub fn from_u32(raw: u32) -> Mark {\\n Mark(raw)\\n }\\n\\n #[inline]\\n pub fn parent(self) -> Mark {\\n HygieneData::with(|data| data.marks[self.0 as usize].parent)\\n }\\n\\n #[inline]\\n pub fn is_builtin(self) -> bool {\\n assert_ne!(self, Mark::root());\\n HygieneData::with(|data| data.marks[self.0 as usize].is_builtin)\\n }\\n\\n #[inline]\\n pub fn set_is_builtin(self, is_builtin: bool) {\\n assert_ne!(self, Mark::root());\\n HygieneData::with(|data| data.marks[self.0 as usize].is_builtin = is_builtin)\\n }\\n\\n pub fn is_descendant_of(mut self, ancestor: Mark) -> bool {\\n HygieneData::with(|data| {\\n while self != ancestor {\\n if self == Mark::root() {\\n return false;\\n }\\n self = data.marks[self.0 as usize].parent;\\n }\\n true\\n })\\n }\\n\\n /// Computes a mark such that both input marks are descendants of (or equal\\n /// to) the returned mark. That is, the following holds:\\n ///\\n /// ```rust,ignore\\n /// let la = least_ancestor(a, b);\\n /// assert!(a.is_descendant_of(la))\\n /// assert!(b.is_descendant_of(la))\\n /// ```\\n pub fn least_ancestor(mut a: Mark, mut b: Mark) -> Mark {\\n HygieneData::with(|data| {\\n // Compute the path from a to the root\\n let mut a_path = HashSet::::default();\\n while a != Mark::root() {\\n a_path.insert(a);\\n a = data.marks[a.0 as usize].parent;\\n }\\n\\n // While the path from b to the root hasn\\'t intersected, move up the tree\\n while !a_path.contains(&b) {\\n b = data.marks[b.0 as usize].parent;\\n }\\n\\n b\\n })\\n }\\n}\\n\\n#[derive(Debug)]\\npub(crate) struct HygieneData {\\n marks: Vec,\\n syntax_contexts: Vec,\\n markings: FxHashMap<(SyntaxContext, Mark), SyntaxContext>,\\n}\\n\\nimpl Default for HygieneData {\\n fn default() -> Self {\\n Self::new()\\n }\\n}\\n\\nimpl HygieneData {\\n pub(crate) fn new() -> Self {\\n HygieneData {\\n marks: vec![MarkData {\\n parent: Mark::root(),\\n // If the root is opaque, then loops searching for an opaque mark\\n // will automatically stop after reaching it.\\n is_builtin: true,\\n }],\\n syntax_contexts: vec![SyntaxContextData {\\n outer_mark: Mark::root(),\\n prev_ctxt: SyntaxContext(0),\\n opaque: SyntaxContext(0),\\n opaque_and_semitransparent: SyntaxContext(0),\\n }],\\n markings: HashMap::default(),\\n }\\n }\\n\\n fn with T>(f: F) -> T {\\n GLOBALS.with(|globals| {\\n #[cfg(feature = \"parking_lot\")]\\n return f(&mut *globals.hygiene_data.lock());\\n\\n #[cfg(not(feature = \"parking_lot\"))]\\n return f(&mut *globals.hygiene_data.lock().unwrap());\\n })\\n }\\n}\\n\\n// pub fn clear_markings() {\\n// HygieneData::with(|data| data.markings = HashMap::default());\\n// }\\n\\nimpl SyntaxContext {\\n pub const fn empty() -> Self {\\n SyntaxContext(0)\\n }\\n\\n // pub(crate) fn as_u32(self) -> u32 {\\n // self.0\\n // }\\n //\\n // pub(crate) fn from_u32(raw: u32) -> SyntaxContext {\\n // SyntaxContext(raw)\\n // }\\n\\n /// Extend a syntax context with a given mark and default transparency for\\n /// that mark.\\n pub fn apply_mark(self, mark: Mark) -> SyntaxContext {\\n assert_ne!(mark, Mark::root());\\n return self.apply_mark_internal(mark);\\n }\\n\\n fn apply_mark_internal(self, mark: Mark) -> SyntaxContext {\\n HygieneData::with(|data| {\\n let syntax_contexts = &mut data.syntax_contexts;\\n let mut opaque = syntax_contexts[self.0 as usize].opaque;\\n let opaque_and_semitransparent =\\n syntax_contexts[self.0 as usize].opaque_and_semitransparent;\\n\\n let prev_ctxt = opaque;\\n opaque = *data.markings.entry((prev_ctxt, mark)).or_insert_with(|| {\\n let new_opaque = SyntaxContext(syntax_contexts.len() as u32);\\n syntax_contexts.push(SyntaxContextData {\\n outer_mark: mark,\\n prev_ctxt,\\n opaque: new_opaque,\\n opaque_and_semitransparent: new_opaque,\\n });\\n new_opaque\\n });\\n\\n let prev_ctxt = self;\\n *data.markings.entry((prev_ctxt, mark)).or_insert_with(|| {\\n let new_opaque_and_semitransparent_and_transparent =\\n SyntaxContext(syntax_contexts.len() as u32);\\n syntax_contexts.push(SyntaxContextData {\\n outer_mark: mark,\\n prev_ctxt,\\n opaque,\\n opaque_and_semitransparent,\\n });\\n new_opaque_and_semitransparent_and_transparent\\n })\\n })\\n }\\n\\n /// Pulls a single mark off of the syntax context. This effectively moves\\n /// the context up one macro definition level. That is, if we have a\\n /// nested macro definition as follows:\\n ///\\n /// ```rust,ignore\\n /// macro_rules! f {\\n /// macro_rules! g {\\n /// ...\\n /// }\\n /// }\\n /// ```\\n ///\\n /// and we have a SyntaxContext that is referring to something declared by\\n /// an invocation of g (call it g1), calling remove_mark will result in\\n /// the SyntaxContext for the invocation of f that created g1.\\n /// Returns the mark that was removed.\\n pub fn remove_mark(&mut self) -> Mark {\\n HygieneData::with(|data| {\\n let outer_mark = data.syntax_contexts[self.0 as usize].outer_mark;\\n *self = data.syntax_contexts[self.0 as usize].prev_ctxt;\\n outer_mark\\n })\\n }\\n\\n /// Adjust this context for resolution in a scope created by the given\\n /// expansion. For example, consider the following three resolutions of\\n /// `f`:\\n ///\\n /// ```rust,ignore\\n /// mod foo {\\n /// pub fn f() {}\\n /// } // `f`\\'s `SyntaxContext` is empty.\\n /// m!(f);\\n /// macro m($f:ident) {\\n /// mod bar {\\n /// pub fn f() {} // `f`\\'s `SyntaxContext` has a single `Mark` from `m`.\\n /// pub fn $f() {} // `$f`\\'s `SyntaxContext` is empty.\\n /// }\\n /// foo::f(); // `f`\\'s `SyntaxContext` has a single `Mark` from `m`\\n /// //^ Since `mod foo` is outside this expansion, `adjust` removes the mark from `f`,\\n /// //| and it resolves to `::foo::f`.\\n /// bar::f(); // `f`\\'s `SyntaxContext` has a single `Mark` from `m`\\n /// //^ Since `mod bar` not outside this expansion, `adjust` does not change `f`,\\n /// //| and it resolves to `::bar::f`.\\n /// bar::$f(); // `f`\\'s `SyntaxContext` is empty.\\n /// //^ Since `mod bar` is not outside this expansion, `adjust` does not change `$f`,\\n /// //| and it resolves to `::bar::$f`.\\n /// }\\n /// ```\\n /// This returns the expansion whose definition scope we use to privacy\\n /// check the resolution, or `None` if we privacy check as usual (i.e.\\n /// not w.r.t. a macro definition scope).\\n pub fn adjust(&mut self, expansion: Mark) -> Option {\\n let mut scope = None;\\n while !expansion.is_descendant_of(self.outer()) {\\n scope = Some(self.remove_mark());\\n }\\n scope\\n }\\n\\n /// Adjust this context for resolution in a scope created by the given\\n /// expansion via a glob import with the given `SyntaxContext`.\\n /// For example:\\n ///\\n /// ```rust,ignore\\n /// m!(f);\\n /// macro m($i:ident) {\\n /// mod foo {\\n /// pub fn f() {} // `f`\\'s `SyntaxContext` has a single `Mark` from `m`.\\n /// pub fn $i() {} // `$i`\\'s `SyntaxContext` is empty.\\n /// }\\n /// n(f);\\n /// macro n($j:ident) {\\n /// use foo::*;\\n /// f(); // `f`\\'s `SyntaxContext` has a mark from `m` and a mark from `n`\\n /// //^ `glob_adjust` removes the mark from `n`, so this resolves to `foo::f`.\\n /// $i(); // `$i`\\'s `SyntaxContext` has a mark from `n`\\n /// //^ `glob_adjust` removes the mark from `n`, so this resolves to `foo::$i`.\\n /// $j(); // `$j`\\'s `SyntaxContext` has a mark from `m`\\n /// //^ This cannot be glob-adjusted, so this is a resolution error.\\n /// }\\n /// }\\n /// ```\\n /// This returns `None` if the context cannot be glob-adjusted.\\n /// Otherwise, it returns the scope to use when privacy checking (see\\n /// `adjust` for details).\\n pub fn glob_adjust(\\n &mut self,\\n expansion: Mark,\\n mut glob_ctxt: SyntaxContext,\\n ) -> Option> {\\n let mut scope = None;\\n while !expansion.is_descendant_of(glob_ctxt.outer()) {\\n scope = Some(glob_ctxt.remove_mark());\\n if self.remove_mark() != scope.unwrap() {\\n return None;\\n }\\n }\\n if self.adjust(expansion).is_some() {\\n return None;\\n }\\n Some(scope)\\n }\\n\\n /// Undo `glob_adjust` if possible:\\n ///\\n /// ```rust,ignore\\n /// if let Some(privacy_checking_scope) = self.reverse_glob_adjust(expansion, glob_ctxt) {\\n /// assert!(self.glob_adjust(expansion, glob_ctxt) == Some(privacy_checking_scope));\\n /// }\\n /// ```\\n pub fn reverse_glob_adjust(\\n &mut self,\\n expansion: Mark,\\n mut glob_ctxt: SyntaxContext,\\n ) -> Option> {\\n if self.adjust(expansion).is_some() {\\n return None;\\n }\\n\\n let mut marks = Vec::new();\\n while !expansion.is_descendant_of(glob_ctxt.outer()) {\\n marks.push(glob_ctxt.remove_mark());\\n }\\n\\n let scope = marks.last().cloned();\\n while let Some(mark) = marks.pop() {\\n *self = self.apply_mark(mark);\\n }\\n Some(scope)\\n }\\n\\n #[inline]\\n pub fn outer(self) -> Mark {\\n HygieneData::with(|data| data.syntax_contexts[self.0 as usize].outer_mark)\\n }\\n}\\n\\nimpl fmt::Debug for SyntaxContext {\\n fn fmt(&self, f: &mut fmt::Formatter<\\'_>) -> fmt::Result {\\n write!(f, \"#{}\", self.0)\\n }\\n}\\n\\nimpl Default for Mark {\\n fn default() -> Self {\\n Mark::root()\\n }\\n}\\n',\n", + " 'content_id': '546d4f8dc563fc60a56dbd25e0bccdbc7e42d952',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 104,\n", + " 'path': '/common/src/syntax_pos/hygiene.rs',\n", + " 'size': 13025,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.40678291319885834,\n", + " 'avg_line_length': 27.95347222222222,\n", + " 'blob_id': '750e210bfbe5597ad1d72c5481baecfcca082cc8',\n", + " 'content': 'use crate::ext::{AsOptExpr, PatOrExprExt};\\nuse rustc_hash::FxHashMap;\\nuse swc_common::{comments::Comments, util::take::Take, Span, Spanned};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\n\\n/// Fixes ast nodes before printing so semantics are preserved.\\n///\\n/// You don\\'t have to bother to create appropriate parenthesis.\\n/// The pass will insert parenthesis as needed. In other words, it\\'s\\n/// okay to store `a * (b + c)` as `Bin { a * Bin { b + c } }`.\\n\\npub fn fixer<\\'a>(comments: Option<&\\'a dyn Comments>) -> impl \\'a + Fold + VisitMut {\\n as_folder(Fixer {\\n comments,\\n ctx: Default::default(),\\n span_map: Default::default(),\\n in_for_stmt_head: Default::default(),\\n })\\n}\\n\\nstruct Fixer<\\'a> {\\n comments: Option<&\\'a dyn Comments>,\\n ctx: Context,\\n /// A hash map to preserve original span.\\n ///\\n /// Key is span of inner expression, and value is span of the paren\\n /// expression.\\n span_map: FxHashMap,\\n\\n in_for_stmt_head: bool,\\n}\\n\\n#[repr(u8)]\\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\\nenum Context {\\n Default,\\n\\n Callee {\\n is_new: bool,\\n },\\n /// Always treated as expr. (But number of comma-separated expression\\n /// matters)\\n ///\\n /// - `foo((bar, x))` != `foo(bar, x)`\\n /// - `var foo = (bar, x)` != `var foo = bar, x`\\n /// - `[(foo, bar)]` != `[foo, bar]`\\n ForcedExpr {\\n is_var_decl: bool,\\n },\\n\\n /// Always treated as expr and comma does not matter.\\n FreeExpr,\\n}\\n\\nimpl Default for Context {\\n fn default() -> Self {\\n Context::Default\\n }\\n}\\n\\nmacro_rules! array {\\n ($name:ident, $T:tt) => {\\n fn $name(&mut self, e: &mut $T) {\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: false }.into();\\n e.elems.visit_mut_with(self);\\n self.ctx = old;\\n }\\n };\\n}\\n\\nimpl VisitMut for Fixer<\\'_> {\\n noop_visit_mut_type!();\\n\\n array!(visit_mut_array_lit, ArrayLit);\\n // array!(ArrayPat);\\n\\n fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {\\n let old = self.ctx;\\n self.ctx = Context::Default;\\n node.visit_mut_children_with(self);\\n match &mut node.body {\\n BlockStmtOrExpr::Expr(ref mut e) if e.is_seq() => {\\n self.wrap(&mut **e);\\n }\\n\\n BlockStmtOrExpr::Expr(ref mut e) if e.is_assign() => match &**e {\\n Expr::Assign(assign) => match &assign.left {\\n PatOrExpr::Pat(l) => match &**l {\\n Pat::Ident(..) | Pat::Expr(..) => {}\\n _ => {\\n self.wrap(&mut **e);\\n }\\n },\\n PatOrExpr::Expr(..) => {}\\n },\\n _ => {}\\n },\\n\\n _ => {}\\n };\\n self.ctx = old;\\n }\\n\\n fn visit_mut_assign_expr(&mut self, expr: &mut AssignExpr) {\\n expr.visit_mut_children_with(self);\\n\\n match &mut *expr.right {\\n // `foo = (bar = baz)` => foo = bar = baz\\n Expr::Assign(AssignExpr { ref left, .. }) if left.as_ident().is_some() => {}\\n\\n Expr::Seq(..) => self.wrap(&mut expr.right),\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {\\n node.visit_mut_children_with(self);\\n\\n match &*node.right {\\n Expr::Seq(..) => {\\n self.wrap(&mut *node.right);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {\\n node.key.visit_mut_children_with(self);\\n\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: false };\\n node.value.visit_mut_with(self);\\n self.ctx = old;\\n }\\n\\n fn visit_mut_await_expr(&mut self, expr: &mut AwaitExpr) {\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: false };\\n expr.arg.visit_mut_with(self);\\n self.ctx = old;\\n\\n match &*expr.arg {\\n Expr::Cond(..)\\n | Expr::Assign(..)\\n | Expr::Bin(..)\\n | Expr::Unary(..)\\n | Expr::Update(..) => self.wrap(&mut expr.arg),\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_bin_expr(&mut self, expr: &mut BinExpr) {\\n expr.visit_mut_children_with(self);\\n\\n match expr.op {\\n op!(\"||\") | op!(\"&&\") => match (&*expr.left, &*expr.right) {\\n (Expr::Update(..), Expr::Call(..)) => {\\n return;\\n }\\n\\n (Expr::Update(..), Expr::Assign(..)) => {\\n self.wrap(&mut expr.right);\\n return;\\n }\\n\\n _ => {}\\n },\\n\\n op!(\">\") | op!(\">=\") | op!(\"<\") | op!(\"<=\") => match (&*expr.left, &*expr.right) {\\n (Expr::Update(..) | Expr::Lit(..), Expr::Update(..) | Expr::Lit(..)) => {\\n return;\\n }\\n\\n _ => {}\\n },\\n\\n op!(\"**\") => match &*expr.left {\\n Expr::Unary(..) => {\\n self.wrap(&mut expr.left);\\n }\\n Expr::Lit(Lit::Num(v)) if v.value.is_sign_negative() => {\\n self.wrap(&mut expr.left);\\n }\\n _ => {}\\n },\\n\\n _ => {}\\n }\\n\\n match &mut *expr.right {\\n Expr::Assign(..)\\n | Expr::Seq(..)\\n | Expr::Yield(..)\\n | Expr::Cond(..)\\n | Expr::Arrow(..) => {\\n self.wrap(&mut expr.right);\\n }\\n Expr::Bin(BinExpr { op: op_of_rhs, .. }) => {\\n if *op_of_rhs == expr.op {\\n match expr.op {\\n op!(\"&&\") | op!(\"||\") => {}\\n _ => {\\n self.wrap(&mut expr.right);\\n }\\n }\\n } else if op_of_rhs.precedence() <= expr.op.precedence()\\n || (*op_of_rhs == op!(\"&&\") && expr.op == op!(\"??\"))\\n {\\n self.wrap(&mut expr.right);\\n }\\n }\\n _ => {}\\n };\\n\\n match &mut *expr.left {\\n Expr::Bin(BinExpr { op: op!(\"??\"), .. }) => {\\n self.wrap(&mut expr.left);\\n }\\n\\n // While simplifying, (1 + x) * Nan becomes `1 + x * Nan`.\\n // But it should be `(1 + x) * Nan`\\n Expr::Bin(BinExpr { op: op_of_lhs, .. }) => {\\n if op_of_lhs.precedence() < expr.op.precedence()\\n || (op_of_lhs.precedence() == expr.op.precedence() && expr.op == op!(\"**\"))\\n {\\n self.wrap(&mut expr.left);\\n }\\n }\\n\\n Expr::Unary(UnaryExpr {\\n op: op!(\"void\"), ..\\n }) if expr.op == op!(\"==\")\\n || expr.op == op!(\"===\")\\n || expr.op == op!(\"!=\")\\n || expr.op == op!(\"!==\") => {}\\n\\n Expr::Seq(..)\\n | Expr::Update(UpdateExpr { prefix: false, .. })\\n | Expr::Unary(UnaryExpr {\\n op: op!(\"delete\"), ..\\n })\\n | Expr::Unary(UnaryExpr {\\n op: op!(\"void\"), ..\\n })\\n | Expr::Yield(..)\\n | Expr::Cond(..)\\n | Expr::Assign(..)\\n | Expr::Arrow(..) => {\\n self.wrap(&mut expr.left);\\n }\\n Expr::Object(..)\\n if expr.op == op!(\"instanceof\")\\n || expr.op == op!(\"==\")\\n || expr.op == op!(\"===\")\\n || expr.op == op!(\"!=\")\\n || expr.op == op!(\"!==\") =>\\n {\\n self.wrap(&mut expr.left)\\n }\\n _ => {}\\n }\\n\\n match expr.op {\\n op!(\"??\") => match &mut *expr.left {\\n Expr::Bin(..) => {\\n self.wrap(&mut expr.left);\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_block_stmt_or_expr(&mut self, body: &mut BlockStmtOrExpr) {\\n body.visit_mut_children_with(self);\\n\\n match body {\\n BlockStmtOrExpr::Expr(ref mut expr) if expr.is_object() => {\\n self.wrap(&mut **expr);\\n }\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: false };\\n node.args.visit_mut_with(self);\\n self.ctx = old;\\n\\n let old = self.ctx;\\n self.ctx = Context::Callee { is_new: false };\\n node.callee.visit_mut_with(self);\\n match &mut node.callee {\\n ExprOrSuper::Expr(e) if e.is_cond() || e.is_bin() || e.is_lit() || e.is_unary() => {\\n self.wrap(&mut **e);\\n }\\n _ => {}\\n }\\n\\n self.ctx = old;\\n }\\n\\n fn visit_mut_class(&mut self, node: &mut Class) {\\n let old = self.ctx;\\n self.ctx = Context::Default;\\n node.visit_mut_children_with(self);\\n match &mut node.super_class {\\n Some(ref mut e) if e.is_seq() || e.is_await_expr() || e.is_bin() => self.wrap(&mut **e),\\n _ => {}\\n };\\n self.ctx = old;\\n\\n node.body.retain(|m| match m {\\n ClassMember::Empty(..) => false,\\n _ => true,\\n });\\n }\\n\\n fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {\\n let old = self.ctx;\\n self.ctx = Context::Default;\\n node.visit_mut_children_with(self);\\n match &mut *node.expr {\\n Expr::Arrow(..) | Expr::Seq(..) => self.wrap(&mut node.expr),\\n _ => {}\\n };\\n self.ctx = old;\\n }\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n let ctx = self.ctx;\\n self.unwrap_expr(e);\\n e.visit_mut_children_with(self);\\n\\n self.ctx = ctx;\\n self.wrap_with_paren_if_required(e)\\n }\\n\\n fn visit_mut_expr_or_spread(&mut self, e: &mut ExprOrSpread) {\\n e.visit_mut_children_with(self);\\n\\n if e.spread.is_none() {\\n match *e.expr {\\n Expr::Yield(..) => {\\n self.wrap(&mut e.expr);\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_mut_expr_stmt(&mut self, s: &mut ExprStmt) {\\n let old = self.ctx;\\n self.ctx = Context::Default;\\n s.expr.visit_mut_with(self);\\n self.ctx = old;\\n\\n self.handle_expr_stmt(&mut *s.expr);\\n }\\n\\n fn visit_mut_for_of_stmt(&mut self, s: &mut ForOfStmt) {\\n s.visit_mut_children_with(self);\\n\\n match &*s.right {\\n Expr::Seq(..) | Expr::Await(..) => self.wrap(&mut s.right),\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_for_stmt(&mut self, n: &mut ForStmt) {\\n let old = self.in_for_stmt_head;\\n self.in_for_stmt_head = true;\\n n.init.visit_mut_with(self);\\n n.test.visit_mut_with(self);\\n n.update.visit_mut_with(self);\\n\\n self.in_for_stmt_head = false;\\n n.body.visit_mut_with(self);\\n self.in_for_stmt_head = old;\\n }\\n\\n fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {\\n node.visit_mut_children_with(self);\\n\\n if will_eat_else_token(&node.cons) {\\n node.cons = Box::new(Stmt::Block(BlockStmt {\\n span: node.cons.span(),\\n stmts: vec![*node.cons.take()],\\n }));\\n }\\n }\\n\\n fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: false };\\n node.key.visit_mut_with(self);\\n self.ctx = old;\\n\\n node.value.visit_mut_with(self);\\n }\\n fn visit_mut_key_value_prop(&mut self, prop: &mut KeyValueProp) {\\n prop.visit_mut_children_with(self);\\n\\n match *prop.value {\\n Expr::Seq(..) => self.wrap(&mut prop.value),\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_member_expr(&mut self, n: &mut MemberExpr) {\\n n.obj.visit_mut_with(self);\\n n.prop.visit_mut_with(self);\\n\\n match n {\\n MemberExpr { obj, .. }\\n if obj.as_expr().map(|e| e.is_object()).unwrap_or(false)\\n && match self.ctx {\\n Context::ForcedExpr { .. } => true,\\n _ => false,\\n } => {}\\n\\n MemberExpr {\\n obj: ExprOrSuper::Expr(ref mut obj),\\n ..\\n } if obj.is_fn_expr()\\n || obj.is_cond()\\n || obj.is_unary()\\n || obj.is_seq()\\n || obj.is_update()\\n || obj.is_bin()\\n || obj.is_object()\\n || obj.is_assign()\\n || obj.is_arrow()\\n || obj.is_class()\\n || obj.is_yield_expr()\\n || obj.is_await_expr()\\n || (obj.is_call()\\n && match self.ctx {\\n Context::Callee { is_new: true } => true,\\n _ => false,\\n })\\n || match **obj {\\n Expr::New(NewExpr { args: None, .. }) => true,\\n _ => false,\\n } =>\\n {\\n self.wrap(&mut **obj);\\n return;\\n }\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_module(&mut self, n: &mut Module) {\\n debug_assert!(self.span_map.is_empty());\\n self.span_map.clear();\\n\\n let n = n.visit_mut_children_with(self);\\n if let Some(c) = self.comments {\\n for (to, from) in self.span_map.drain() {\\n c.move_leading(from.lo, to.lo);\\n c.move_trailing(from.hi, to.hi);\\n }\\n }\\n\\n n\\n }\\n\\n fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: false };\\n node.args.visit_mut_with(self);\\n self.ctx = old;\\n\\n let old = self.ctx;\\n self.ctx = Context::Callee { is_new: true };\\n node.callee.visit_mut_with(self);\\n match *node.callee {\\n Expr::Call(..)\\n | Expr::Await(..)\\n | Expr::Bin(..)\\n | Expr::Assign(..)\\n | Expr::Seq(..)\\n | Expr::Unary(..)\\n | Expr::Lit(..) => self.wrap(&mut node.callee),\\n _ => {}\\n }\\n self.ctx = old;\\n }\\n\\n fn visit_mut_param(&mut self, node: &mut Param) {\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: false };\\n node.visit_mut_children_with(self);\\n self.ctx = old;\\n }\\n\\n fn visit_mut_prop_name(&mut self, name: &mut PropName) {\\n name.visit_mut_children_with(self);\\n\\n match name {\\n PropName::Computed(c) if c.expr.is_seq() => {\\n self.wrap(&mut c.expr);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_script(&mut self, n: &mut Script) {\\n debug_assert!(self.span_map.is_empty());\\n self.span_map.clear();\\n\\n let n = n.visit_mut_children_with(self);\\n if let Some(c) = self.comments {\\n for (to, from) in self.span_map.drain() {\\n c.move_leading(from.lo, to.lo);\\n c.move_trailing(from.hi, to.hi);\\n }\\n }\\n\\n n\\n }\\n\\n fn visit_mut_stmt(&mut self, s: &mut Stmt) {\\n let old = self.ctx;\\n self.ctx = Context::Default;\\n s.visit_mut_children_with(self);\\n self.ctx = old;\\n }\\n\\n fn visit_mut_tagged_tpl(&mut self, e: &mut TaggedTpl) {\\n e.visit_mut_children_with(self);\\n\\n match &*e.tag {\\n Expr::Arrow(..)\\n | Expr::Cond(..)\\n | Expr::Bin(..)\\n | Expr::Seq(..)\\n | Expr::Fn(..)\\n | Expr::Assign(..)\\n | Expr::Unary(..) => {\\n self.wrap(&mut e.tag);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_unary_expr(&mut self, n: &mut UnaryExpr) {\\n let old = self.ctx;\\n self.ctx = Context::FreeExpr;\\n n.visit_mut_children_with(self);\\n self.ctx = old;\\n\\n match &*n.arg {\\n Expr::Bin(BinExpr {\\n op: op!(\"/\") | op!(\"*\"),\\n left,\\n right,\\n ..\\n }) if n.op == op!(unary, \"-\")\\n && match (&**left, &**right) {\\n (Expr::Lit(Lit::Num(..)), Expr::Lit(Lit::Num(..))) => true,\\n _ => false,\\n } => {}\\n\\n Expr::Assign(..)\\n | Expr::Bin(..)\\n | Expr::Seq(..)\\n | Expr::Cond(..)\\n | Expr::Arrow(..)\\n | Expr::Yield(..) => self.wrap(&mut n.arg),\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {\\n node.name.visit_mut_children_with(self);\\n\\n let old = self.ctx;\\n self.ctx = Context::ForcedExpr { is_var_decl: true };\\n node.init.visit_mut_with(self);\\n self.ctx = old;\\n }\\n}\\n\\nimpl Fixer<\\'_> {\\n fn wrap_with_paren_if_required(&mut self, e: &mut Expr) {\\n let mut has_padding_value = false;\\n match e {\\n Expr::Bin(BinExpr { op: op!(\"in\"), .. }) if self.in_for_stmt_head => {\\n self.wrap(e);\\n }\\n\\n // Flatten seq expr\\n Expr::Seq(SeqExpr { span, exprs }) => {\\n let len = exprs\\n .iter()\\n .map(|expr| match **expr {\\n Expr::Paren(ParenExpr { ref expr, .. }) => {\\n if let Expr::Seq(SeqExpr { exprs, .. }) = expr.as_ref() {\\n exprs.len()\\n } else {\\n 1\\n }\\n }\\n Expr::Seq(SeqExpr { ref exprs, .. }) => exprs.len(),\\n _ => 1,\\n })\\n .sum();\\n\\n let exprs_len = exprs.len();\\n // don\\'t has child seq\\n let expr = if len == exprs_len {\\n let mut exprs = exprs\\n .into_iter()\\n .enumerate()\\n .filter_map(|(i, e)| {\\n let is_last = i + 1 == exprs_len;\\n if is_last {\\n Some(e.take())\\n } else {\\n ignore_return_value(e.take(), &mut has_padding_value)\\n }\\n })\\n .collect::>();\\n if exprs.len() == 1 {\\n *e = *exprs.pop().unwrap();\\n return;\\n }\\n let exprs = ignore_padding_value(exprs);\\n Expr::Seq(SeqExpr { span: *span, exprs })\\n } else {\\n let mut buf = Vec::with_capacity(len);\\n for (i, expr) in exprs.into_iter().enumerate() {\\n let is_last = i + 1 == exprs_len;\\n\\n match **expr {\\n Expr::Seq(SeqExpr { ref mut exprs, .. }) => {\\n let exprs = exprs.take();\\n if !is_last {\\n buf.extend(exprs.into_iter().filter_map(|expr| {\\n ignore_return_value(expr, &mut has_padding_value)\\n }));\\n } else {\\n let exprs_len = exprs.len();\\n for (i, expr) in exprs.into_iter().enumerate() {\\n let is_last = i + 1 == exprs_len;\\n if is_last {\\n buf.push(expr);\\n } else {\\n buf.extend(ignore_return_value(\\n expr,\\n &mut has_padding_value,\\n ));\\n }\\n }\\n }\\n }\\n _ => {\\n if is_last {\\n buf.push(expr.take());\\n } else {\\n buf.extend(ignore_return_value(\\n expr.take(),\\n &mut has_padding_value,\\n ));\\n }\\n }\\n }\\n }\\n\\n if buf.len() == 1 {\\n *e = *buf.pop().unwrap();\\n return;\\n }\\n\\n let exprs = ignore_padding_value(buf);\\n\\n Expr::Seq(SeqExpr { span: *span, exprs })\\n };\\n\\n match self.ctx {\\n Context::ForcedExpr { .. } => {\\n *e = Expr::Paren(ParenExpr {\\n span: *span,\\n expr: Box::new(expr),\\n })\\n }\\n _ => *e = expr,\\n };\\n }\\n\\n Expr::Cond(expr) => {\\n match &mut *expr.test {\\n Expr::Seq(..)\\n | Expr::Assign(..)\\n | Expr::Cond(..)\\n | Expr::Arrow(..)\\n | Expr::Yield(..) => self.wrap(&mut expr.test),\\n\\n Expr::Object(..) | Expr::Fn(..) | Expr::Class(..) => {\\n if self.ctx == Context::Default {\\n self.wrap(&mut expr.test)\\n }\\n }\\n _ => {}\\n };\\n\\n match *expr.cons {\\n Expr::Seq(..) => self.wrap(&mut expr.cons),\\n _ => {}\\n };\\n\\n match *expr.alt {\\n Expr::Seq(..) => self.wrap(&mut expr.alt),\\n _ => {}\\n };\\n\\n match self.ctx {\\n Context::Callee { is_new: true } => self.wrap(e),\\n _ => {}\\n }\\n }\\n\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(ref mut callee),\\n ..\\n }) if callee.is_seq() => {\\n *callee = Box::new(Expr::Paren(ParenExpr {\\n span: callee.span(),\\n expr: callee.take(),\\n }))\\n }\\n\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(ref mut callee),\\n ..\\n }) if callee.is_arrow() || callee.is_await_expr() => {\\n self.wrap(&mut **callee);\\n }\\n\\n // Function expression cannot start with `function`\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(ref mut callee),\\n ..\\n }) if callee.is_fn_expr() => match self.ctx {\\n Context::ForcedExpr { .. } | Context::FreeExpr => {}\\n\\n Context::Callee { is_new: true } => self.wrap(e),\\n\\n _ => self.wrap(&mut **callee),\\n },\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(ref mut callee),\\n ..\\n }) if callee.is_assign() => self.wrap(&mut **callee),\\n _ => {}\\n }\\n }\\n\\n /// Wrap with a paren.\\n fn wrap(&mut self, e: &mut Expr) {\\n let span = e.span();\\n\\n let span = if let Some(span) = self.span_map.remove(&span) {\\n span\\n } else {\\n span\\n };\\n\\n let expr = Box::new(e.take());\\n *e = Expr::Paren(ParenExpr { expr, span })\\n }\\n\\n /// Removes paren\\n fn unwrap_expr(&mut self, e: &mut Expr) {\\n match &*e {\\n Expr::Paren(paren) => match &*paren.expr {\\n Expr::Call(..) | Expr::Fn(..) => {}\\n _ => {\\n let inner_span = paren.span;\\n if let Some(comments) = self.comments {\\n if comments.has_leading(inner_span.lo) {\\n return;\\n }\\n }\\n }\\n },\\n _ => {}\\n }\\n\\n match e {\\n Expr::Seq(SeqExpr { ref mut exprs, .. }) if exprs.len() == 1 => {\\n self.unwrap_expr(exprs.last_mut().unwrap());\\n *e = *exprs.last_mut().unwrap().take();\\n }\\n Expr::Paren(ParenExpr {\\n span: paren_span,\\n ref mut expr,\\n ..\\n }) => {\\n let expr_span = expr.span();\\n let paren_span = *paren_span;\\n self.unwrap_expr(&mut **expr);\\n *e = *expr.take();\\n\\n self.span_map.insert(expr_span, paren_span);\\n }\\n _ => {}\\n }\\n }\\n\\n fn handle_expr_stmt(&mut self, expr: &mut Expr) {\\n match expr {\\n // It\\'s important for arrow pass to work properly.\\n Expr::Object(..) | Expr::Class(..) | Expr::Fn(..) => self.wrap(expr),\\n\\n // ({ a } = foo)\\n Expr::Assign(AssignExpr {\\n left: PatOrExpr::Pat(left),\\n ..\\n }) if left.is_object() => self.wrap(expr),\\n\\n Expr::Seq(SeqExpr { exprs, .. }) => {\\n debug_assert!(\\n exprs.len() != 1,\\n \"SeqExpr should be unwrapped if exprs.len() == 1, but length is 1\"\\n );\\n\\n let len = exprs.len();\\n exprs.into_iter().enumerate().for_each(|(i, mut expr)| {\\n let is_last = len == i + 1;\\n\\n if !is_last {\\n self.handle_expr_stmt(&mut expr);\\n }\\n });\\n }\\n\\n _ => {}\\n }\\n }\\n}\\n\\nfn ignore_return_value(expr: Box, has_padding_value: &mut bool) -> Option> {\\n match *expr {\\n Expr::Fn(..) | Expr::Arrow(..) | Expr::Lit(..) => {\\n if *has_padding_value {\\n None\\n } else {\\n *has_padding_value = true;\\n Some(expr)\\n }\\n }\\n Expr::Seq(SeqExpr { span, exprs }) => {\\n let len = exprs.len();\\n let mut exprs: Vec<_> = exprs\\n .into_iter()\\n .enumerate()\\n .filter_map(|(i, expr)| {\\n if i + 1 == len {\\n Some(expr)\\n } else {\\n ignore_return_value(expr, has_padding_value)\\n }\\n })\\n .collect();\\n\\n match exprs.len() {\\n 0 | 1 => exprs.pop(),\\n _ => Some(Box::new(Expr::Seq(SeqExpr { span, exprs }))),\\n }\\n }\\n Expr::Unary(UnaryExpr {\\n op: op!(\"void\"),\\n arg,\\n ..\\n }) => ignore_return_value(arg, has_padding_value),\\n _ => Some(expr),\\n }\\n}\\n\\n// at least 3 element in seq, which means we can safely\\n// remove that padding, if not at last position\\nfn ignore_padding_value(exprs: Vec>) -> Vec> {\\n let len = exprs.len();\\n\\n if len > 2 {\\n exprs\\n .into_iter()\\n .enumerate()\\n .filter_map(|(i, e)| match e.as_ref() {\\n Expr::Fn(..) | Expr::Arrow(..) | Expr::Lit(..) if i + 1 != len => None,\\n _ => Some(e),\\n })\\n .collect()\\n } else {\\n exprs\\n }\\n}\\n\\nfn will_eat_else_token(s: &Stmt) -> bool {\\n match s {\\n Stmt::If(s) => match &s.alt {\\n Some(alt) => will_eat_else_token(&alt),\\n None => true,\\n },\\n // Ends with `}`.\\n Stmt::Block(..) => false,\\n\\n Stmt::Labeled(s) => will_eat_else_token(&s.body),\\n\\n Stmt::While(s) => will_eat_else_token(&s.body),\\n\\n Stmt::For(s) => will_eat_else_token(&s.body),\\n\\n Stmt::ForIn(s) => will_eat_else_token(&s.body),\\n\\n Stmt::ForOf(s) => will_eat_else_token(&s.body),\\n\\n _ => false,\\n }\\n}\\n\\n#[cfg(test)]\\nmod tests {\\n use super::fixer;\\n\\n fn run_test(from: &str, to: &str) {\\n crate::tests::test_transform(\\n Default::default(),\\n |_| fixer(None),\\n from,\\n to,\\n true,\\n Default::default(),\\n );\\n }\\n\\n macro_rules! test_fixer {\\n ($name:ident, $from:literal, $to:literal) => {\\n #[test]\\n fn $name() {\\n run_test($from, $to);\\n }\\n };\\n }\\n\\n macro_rules! identical {\\n ($name:ident, $src:literal) => {\\n test_fixer!($name, $src, $src);\\n };\\n }\\n\\n identical!(fn_expr_position, r#\"foo(function(){}())\"#);\\n\\n identical!(fn_decl, r#\"function foo(){}\"#);\\n\\n identical!(iife, r#\"(function(){})()\"#);\\n\\n identical!(paren_seq_arg, \"foo(( _temp = _this = init(), _temp));\");\\n\\n identical!(\\n regression_01,\\n \"_set(_getPrototypeOf(Obj.prototype), _ref = proper.prop, (_superRef = \\\\\\n +_get(_getPrototypeOf(Obj.prototype), _ref, this)) + 1, this, true), _superRef;\"\\n );\\n\\n identical!(\\n regression_02,\\n \"var obj = (_obj = {}, _defineProperty(_obj, \\'first\\', \\'first\\'), _defineProperty(_obj, \\\\\\n \\'second\\', \\'second\\'), _obj);\"\\n );\\n\\n identical!(\\n regression_03,\\n \"_iteratorNormalCompletion = (_step = _iterator.next()).done\"\\n );\\n\\n identical!(\\n regression_04,\\n \"var _tmp;\\nconst _ref = {}, { c =( _tmp = {}, d = _extends({}, _tmp), _tmp) } = _ref;\"\\n );\\n\\n identical!(\\n regression_05,\\n \"for (var _iterator = arr[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step \\\\\\n = _iterator.next()).done); _iteratorNormalCompletion = true) {\\n i = _step.value;\\n}\"\\n );\\n\\n identical!(\\n regression_06,\\n \"\\n var _tmp;\\n const { [( _tmp = {}, d = _extends({}, _tmp), _tmp)]: c } = _ref;\\n \"\\n );\\n\\n identical!(\\n regression_07,\\n \"( _temp = super(), _initialize(this), _temp).method();\"\\n );\\n\\n identical!(regression_08, \"exports.bar = exports.default = void 0;\");\\n\\n identical!(regression_09, \"({x} = { x: 1 });\");\\n\\n identical!(regression_10, \"({x} = { x: 1 }), exports.x = x;\");\\n\\n identical!(regression_11, \"(void 0).foo();\");\\n\\n identical!(regression_12, \"(function(){})()\");\\n\\n identical!(regression_13, \"a || (a = 1);\");\\n\\n identical!(issue_192, \"a === true && (a = true)\");\\n\\n identical!(issue_199, \"(i - 1).toString()\");\\n\\n identical!(\\n issue_201_01,\\n \"outer = {\\n inner: (_obj = {}, _defineProperty(_obj, ns.EXPORT1, true), _defineProperty(_obj, ns.EXPORT2, \\\\\\n true), _obj)\\n};\"\\n );\\n\\n identical!(issue_207, \"a => ({x: \\'xxx\\', y: {a}});\");\\n\\n test_fixer!(\\n fixer_01,\\n \"var a, b, c, d, e, f;\\n((a, b), (c())) + ((d, e), (f()));\\n\",\\n \"var a, b, c, d, e, f;\\n(a, b, c()) + (d, e, f())\"\\n );\\n\\n test_fixer!(fixer_02, \"(b, c), d;\", \"b, c, d;\");\\n\\n test_fixer!(fixer_03, \"((a, b), (c && d)) && e;\", \"(a, b, c && d) && e;\");\\n\\n test_fixer!(fixer_04, \"for ((a, b), c;;) ;\", \"for(a, b, c;;);\");\\n\\n test_fixer!(\\n fixer_05,\\n \"var a, b, c = (1), d, e, f = (2);\\n((a, b), c) + ((d, e), f);\",\\n \"var a, b, c = 1, d, e, f = 2;\\n(a, b, c) + (d, e, f);\"\\n );\\n\\n test_fixer!(\\n fixer_06,\\n \"var a, b, c, d;\\na = ((b, c), d);\",\\n \"var a, b, c, d;\\na = (b, c, d);\"\\n );\\n\\n test_fixer!(\\n fixer_07,\\n \"a => ((b, c) => ((a, b), c));\",\\n \"(a)=>(b, c)=>(a, b, c);\"\\n );\\n\\n test_fixer!(fixer_08, \"typeof (((1), a), (2));\", \"typeof (a, 2)\");\\n\\n test_fixer!(\\n fixer_09,\\n \"(((a, b), c), d) ? e : f;\",\\n \"(a, b, c, d) ? e : f;\"\\n );\\n\\n test_fixer!(\\n fixer_10,\\n \"\\nfunction a() {\\n return (((void (1)), (void (2))), a), (void (3));\\n}\\n\",\\n \"\\nfunction a() {\\n return a, void 3;\\n}\\n\"\\n );\\n\\n test_fixer!(fixer_11, \"c && ((((2), (3)), d), b);\", \"c && (d, b)\");\\n\\n test_fixer!(fixer_12, \"(((a, b), c), d) + e;\", \"(a, b, c, d) + e;\");\\n\\n test_fixer!(fixer_13, \"delete (((1), a), (2));\", \"delete (a, 2)\");\\n\\n test_fixer!(fixer_14, \"(1, 2, a)\", \"1, a\");\\n\\n identical!(issue_231, \"\\'\\' + (truthy && \\'?\\') + truthy;\");\\n\\n identical!(issue_252, \"!!(a && b);\");\\n\\n identical!(issue_255, \"b < 0 ? (t = b, b = 1) : (t = -b, b = 0);\");\\n\\n identical!(\\n issue_266_1,\\n \"\\'Q\\' + +x1 + \\',\\' + +y1 + \\',\\' + (this._x1 = +x) + \\',\\' + (this._y1 = +y);\"\\n );\\n\\n test_fixer!(\\n issue_266_2,\\n \"\\'Q\\' + (+x1) + \\',\\' + (+y1) + \\',\\' + (this._x1 = +x) + \\',\\' + (this._y1 = +y);\",\\n \"\\'Q\\' + +x1 + \\',\\' + +y1 + \\',\\' + (this._x1 = +x) + \\',\\' + (this._y1 = +y);\"\\n );\\n\\n identical!(\\n issue_280,\\n \"e.hasOwnProperty(a) && (t = e[a] ? this[a] = t(n) : \\'target\\' === a ? this.target = r : \\\\\\n this[a] = n[a]);\"\\n );\\n\\n identical!(\\n issue_282,\\n \"!(A = [], B = (function () { return classNames; }).apply(exports, A), B !== undefined && \\\\\\n (module.exports = B));\"\\n );\\n\\n identical!(\\n issue_286,\\n \"var SHARED = \\'__core-js_shared__\\';\\nvar store = global[SHARED] || (global[SHARED] = {});\\n(module.exports = function (key, value) {\\n return store[key] || (store[key] = value !== undefined ? value : {});\\n})(\\'versions\\', []).push({\\n version: core.version,\\n mode: __webpack_require__(39) ? \\'pure\\' : \\'global\\',\\n copyright: \\'© 2018 Denis Pushkarev (zloirock.ru)\\'\\n});\"\\n );\\n\\n identical!(\\n issue_293_1,\\n \"for (var e in a) a.hasOwnProperty(e) && ((b = a[e]) ? this[e] = b(c) : \\'target\\' === e ? \\\\\\n this.target = d : this[e] = c[e]);\"\\n );\\n\\n identical!(\\n issue_293_2,\\n \"(a = rb ? zb(a, c) : Ab(a, c)) ? (b = nb.getPooled(ub.beforeInput, b, c, d), b.data = a, \\\\\\n Ra(b)) : b = null;\"\\n );\\n\\n identical!(member_object_lit, \"({}).foo\");\\n\\n identical!(member_cond_expr, \"(foo ? 1 : 2).foo\");\\n\\n identical!(member_new_exp_1, \"(new Foo).foo\");\\n\\n identical!(member_new_exp_2, \"new ctor().property\");\\n\\n identical!(member_tagged_tpl, \"tag``.foo\");\\n\\n identical!(member_arrow_expr_1, \"(a => a).foo\");\\n\\n identical!(member_arrow_expr_2, \"((a) => a).foo\");\\n\\n identical!(member_class, \"(class Foo{}).foo\");\\n\\n identical!(member_yield, \"function* foo(){ (yield bar).baz }\");\\n\\n identical!(member_await, \"async function foo(){ (await bar).baz }\");\\n\\n identical!(bin_yield_expr_1, \"function* foo(){ (yield foo) && bar }\");\\n\\n identical!(bin_yield_expr_2, \"function* foo(){ bar && (yield foo) }\");\\n\\n identical!(bin_seq_expr_1, \"(foo(), op) || (seq(), foo)\");\\n\\n identical!(bin_seq_expr_2, \"(foo, op) || (seq, foo)\");\\n\\n identical!(cond_object_1, \"let foo = {} ? 1 : 2;\");\\n\\n identical!(cond_object_2, \"({}) ? 1 : 2;\");\\n\\n identical!(cond_in_cond, \"(foo ? 1 : 2) ? 3 : 4\");\\n\\n identical!(arrow_in_cond, \"(() => {}) ? 3 : 4\");\\n\\n identical!(unary_cond_arg, \"void (foo ? 1 : 2)\");\\n\\n identical!(unary_arrow_arg, \"void ((foo) => foo)\");\\n\\n identical!(unary_yield_arg, \"(function* foo() { void (yield foo); })()\");\\n\\n identical!(\\n issue_365,\\n \"const foo = (() => {\\n return 1\\n})();\"\\n );\\n\\n identical!(\\n issue_382_1,\\n \"const myFilter = (arr, filter) => arr.filter(((x) => x) || filter);\"\\n );\\n\\n identical!(\\n issue_382_2,\\n \"const myFilter = (arr, filter) => arr.filter(filter || ((x) => x));\"\\n );\\n\\n identical!(issue_418, \"const a = 1 - (1 - 1)\");\\n\\n test_fixer!(\\n issue_439,\\n \"() => {\\n return (\\n Promise.resolve(\\'foo\\')\\n // Interfering comment\\n .then(() => {})\\n );\\n};\",\\n \"() => {\\n return Promise.resolve(\\'foo\\')\\n // Interfering comment\\n .then(() => {})\\n ;\\n};\"\\n );\\n\\n test_fixer!(\\n issue_451,\\n \"const instance = new (\\n function() {\\n function klass(opts) {\\n this.options = opts;\\n }\\n return (Object.assign(klass.prototype, {\\n method() {}\\n }), klass);\\n }()\\n)({ foo: 1 });\",\\n \"const instance = new (function() {\\n function klass(opts) {\\n this.options = opts;\\n }\\n return Object.assign(klass.prototype, {\\n method () {\\n }\\n }), klass;\\n}())({\\n foo: 1\\n});\"\\n );\\n\\n test_fixer!(void_and_bin, \"(void 0) * 2\", \"(void 0) * 2\");\\n\\n test_fixer!(new_cond, \"new (a ? B : C)()\", \"new (a ? B : C)()\");\\n\\n identical!(issue_931, \"new (eval(\\'Date\\'))();\");\\n\\n identical!(issue_1002, \"new (P || (P = Promise))\");\\n\\n identical!(\\n issue_1050,\\n \"\\n (a) => (set) => (elemE(a, set) ? removeE : insertE)(a)(set)\\n \"\\n );\\n\\n identical!(\\n deno_001,\\n \"\\n var Status;\\n (function init(Status1) {\\n })(Status || (Status = {\\n }));\\n\"\\n );\\n\\n identical!(issue_1093, \"const x = (fnA || fnB)();\");\\n\\n identical!(\\n issue_1133,\\n \"async function foo() {\\n const item = await (data === null || data === void 0 ? void 0 : data.foo());\\n }\"\\n );\\n\\n identical!(deno_8722, \"console.log((true || false) ?? true);\");\\n\\n identical!(\\n deno_8597,\\n \"\\n biasInitializer = new (_a = class CustomInit extends Initializer {})();\\n \"\\n );\\n\\n test_fixer!(\\n minifier_001,\\n \"var bitsLength = 3, bitsOffset = 3, what = (len = 0)\",\\n \"var bitsLength = 3, bitsOffset = 3, what = len = 0\"\\n );\\n\\n test_fixer!(minifier_002, \"!(function(){})()\", \"!function(){}()\");\\n\\n identical!(\\n issue_1397,\\n \"const main = async () => await (await server)()\"\\n );\\n\\n identical!(deno_9810, \"await (bar = Promise.resolve(2));\");\\n\\n identical!(issue_1493, \"(\\'a\\' ?? \\'b\\') || \\'\\'\");\\n identical!(call_seq, \"let x = ({}, () => 2)();\");\\n\\n test_fixer!(\\n call_seq_with_padding,\\n \"let x = ({}, (1, 2), () => 2)();\",\\n \"let x = ({}, () => 2)();\"\\n );\\n\\n identical!(\\n param_seq,\\n \"function t(x = ({}, 2)) {\\n return x;\\n }\"\\n );\\n\\n identical!(\\n yield_expr_cond,\\n \"function *test1(foo) {\\n return (yield foo) ? \\'bar\\' : \\'baz\\';\\n }\"\\n );\\n\\n identical!(\\n deno_10487_1,\\n \"var generator = class MultiVector extends (options.baseType||Float32Array) {}\"\\n );\\n\\n identical!(\\n deno_10487_2,\\n \"class MultiVector extends (options.baseType||Float32Array) {}\"\\n );\\n\\n identical!(deno_10668_1, \"console.log(null ?? (undefined && true))\");\\n\\n identical!(deno_10668_2, \"console.log(null && (undefined ?? true))\");\\n\\n identical!(minifier_003, \"(four ** one) ** two\");\\n\\n identical!(minifier_004, \"(void 0)(0)\");\\n\\n identical!(issue_1781, \"const n = ~~(Math.PI * 10)\");\\n\\n identical!(issue_1789, \"+(+1 / 4)\");\\n\\n identical!(new_member_call_1, \"new (getObj()).ctor()\");\\n test_fixer!(\\n new_member_call_2,\\n \"new (getObj().ctor)()\",\\n \"new (getObj()).ctor()\"\\n );\\n test_fixer!(\\n new_member_call_3,\\n \"new (x.getObj().ctor)()\",\\n \"new (x.getObj()).ctor()\"\\n );\\n identical!(new_call, \"new (getCtor())\");\\n test_fixer!(new_member_1, \"new obj.ctor()\", \"new obj.ctor()\");\\n test_fixer!(new_member_2, \"new (obj.ctor)\", \"new obj.ctor\");\\n\\n identical!(\\n new_await_1,\\n \"async function foo() { new (await getServerImpl())(options) }\"\\n );\\n test_fixer!(minifier_005, \"-(1/0)\", \"-1/0\");\\n\\n test_fixer!(minifier_006, \"-(\\'s\\'/\\'b\\')\", \"-(\\'s\\'/\\'b\\')\");\\n\\n test_fixer!(minifier_007, \"(void 0) === value\", \"void 0 === value\");\\n test_fixer!(minifier_008, \"(size--) && (b = (c))\", \"size-- && (b = c)\");\\n\\n test_fixer!(\\n minifier_009,\\n \"(--remaining) || deferred.resolveWith()\",\\n \"--remaining || deferred.resolveWith()\"\\n );\\n\\n test_fixer!(minifier_010, \"(--remaining) + \\'\\'\", \"--remaining + \\'\\'\");\\n\\n identical!(\\n if_stmt_001,\\n \"\\n export const obj = {\\n each: function (obj, callback, args) {\\n var i = 0, length = obj.length, isArray = isArraylike(obj);\\n if (args) {\\n if (isArray)\\n for (; i < length && !1 !== callback.apply(obj[i], args); i++);\\n else\\n for (i in obj)\\n if (!1 === callback.apply(obj[i], args))\\n break\\n } else if (isArray)\\n for (; i < length && !1 !== callback.call(obj[i], i, obj[i]); i++);\\n else\\n for (i in obj)\\n if (!1 === callback.call(obj[i], i, obj[i]))\\n break;\\n return obj\\n }\\n };\\n \"\\n );\\n\\n identical!(\\n issue_2155,\\n \"\\n async function main() {\\n let promise;\\n await (promise || (promise = Promise.resolve(\\'this is a string\\')));\\n }\\n \"\\n );\\n\\n identical!(issue_2163_1, \"() => ({foo} = bar());\");\\n\\n identical!(issue_2163_2, \"() => ([foo] = bar());\");\\n\\n identical!(issue_2191, \"(-1) ** h\");\\n}\\n',\n", + " 'content_id': 'b350e270fa7dcf672bf1e97a162cf86135cf310b',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/transforms/base/src/fixer.rs',\n", + " 'size': 41693,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6241660489251297,\n", + " 'avg_line_length': 39.878787878787875,\n", + " 'blob_id': 'c91546fdafceed3f8dc55f8f8a99ff8db3b99c72',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_compat/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_compat\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.40.0\"\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\narrayvec = \"0.5.2\"\\nindexmap = \"1.6.1\"\\nis-macro = \"0.1.8\"\\nnum-bigint = \"0.2\"\\nordered-float = \"2.0.1\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1.0.118\", features = [\"derive\"]}\\nsmallvec = \"1.6.0\"\\nswc_atoms = {version = \"0.2.5\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_transforms_classes = {version = \"0.21.0\", path = \"../classes\"}\\nswc_ecma_transforms_macros = {version = \"0.2.1\", path = \"../macros\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\n\\n[dev-dependencies]\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_transforms_testing = {version = \"0.36.0\", path = \"../testing\"}\\ntesting = {version = \"0.14.0\", path = \"../../../testing\"}\\n',\n", + " 'content_id': '09fdb29ffef6afd2e1b6cab761beab2249dd7418',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/transforms/compat/Cargo.toml',\n", + " 'size': 1349,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3990353903155743,\n", + " 'avg_line_length': 31.81761006289308,\n", + " 'blob_id': 'feb0a2c323af3b6cfa0c4f82f7bb20fe43b4f066',\n", + " 'content': 'use self::{\\n constructor::{\\n constructor_fn, make_possible_return_value, replace_this_in_constructor, ConstructorFolder,\\n ReturningMode, SuperCallFinder, SuperFoldingMode, VarRenamer,\\n },\\n prop_name::HashKey,\\n};\\nuse rustc_hash::FxHasher;\\nuse std::{hash::BuildHasherDefault, iter};\\nuse swc_common::{comments::Comments, Mark, Spanned, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::{helper, native::is_native, perf::Check};\\nuse swc_ecma_transforms_classes::super_field::SuperFieldAccessFolder;\\nuse swc_ecma_transforms_macros::fast_path;\\nuse swc_ecma_utils::{\\n alias_if_required, default_constructor, prepend, private_ident, prop_name_to_expr, quote_expr,\\n quote_ident, quote_str, ExprFactory, IsDirective, ModuleItemLike, StmtLike,\\n};\\nuse swc_ecma_visit::{noop_fold_type, noop_visit_type, Fold, FoldWith, Node, Visit, VisitWith};\\n\\nmod constructor;\\nmod prop_name;\\n\\npub fn classes(comments: Option) -> impl Fold\\nwhere\\n C: Comments,\\n{\\n Classes {\\n in_strict: false,\\n comments,\\n }\\n}\\n\\ntype IndexMap = indexmap::IndexMap>;\\n\\n/// `@babel/plugin-transform-classes`\\n///\\n/// # In\\n/// ```js\\n/// class Test {\\n/// constructor(name) {\\n/// this.name = name;\\n/// }\\n///\\n/// logger () {\\n/// console.log(\"Hello\", this.name);\\n/// }\\n/// }\\n/// ```\\n///\\n/// # Out\\n/// ```js\\n/// var Test = function () {\\n/// function Test(name) {\\n/// _classCallCheck(this, Test);\\n///\\n/// this.name = name;\\n/// }\\n///\\n/// Test.prototype.logger = function logger() {\\n/// console.log(\"Hello\", this.name);\\n/// };\\n///\\n/// return Test;\\n/// }();\\n/// ```\\n#[derive(Default, Clone, Copy)]\\nstruct Classes\\nwhere\\n C: Comments,\\n{\\n in_strict: bool,\\n comments: Option,\\n}\\n\\nstruct Data {\\n key_prop: Box,\\n method: Option>,\\n set: Option>,\\n get: Option>,\\n}\\n\\nimpl Classes\\nwhere\\n C: Comments,\\n{\\n fn fold_stmt_like(&mut self, stmts: Vec) -> Vec\\n where\\n T: StmtLike + ModuleItemLike + FoldWith,\\n {\\n let mut buf = Vec::with_capacity(stmts.len());\\n let mut first = true;\\n let old = self.in_strict;\\n\\n for stmt in stmts {\\n match T::try_into_stmt(stmt) {\\n Err(node) => match node.try_into_module_decl() {\\n Ok(decl) => {\\n match decl {\\n ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl: DefaultDecl::Class(ClassExpr { ident, class }),\\n ..\\n }) => {\\n let ident = ident.unwrap_or_else(|| quote_ident!(\"_default\"));\\n\\n let decl = self.fold_class_as_var_decl(ident.clone(), class);\\n let decl = decl.fold_children_with(self);\\n buf.push(T::from_stmt(Stmt::Decl(Decl::Var(decl))));\\n\\n buf.push(\\n match T::try_from_module_decl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span: DUMMY_SP,\\n specifiers: vec![ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: ident,\\n exported: Some(quote_ident!(\"default\")),\\n is_type_only: false,\\n }\\n .into()],\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )) {\\n Ok(t) => t,\\n Err(..) => unreachable!(),\\n },\\n );\\n }\\n ModuleDecl::ExportDecl(ExportDecl {\\n span,\\n decl:\\n Decl::Class(ClassDecl {\\n ident,\\n declare: false,\\n class,\\n }),\\n ..\\n }) => {\\n let decl = self.fold_class_as_var_decl(ident, class);\\n let decl = decl.fold_children_with(self);\\n buf.push(\\n match T::try_from_module_decl(ModuleDecl::ExportDecl(\\n ExportDecl {\\n span,\\n decl: Decl::Var(decl),\\n },\\n )) {\\n Ok(t) => t,\\n Err(..) => unreachable!(),\\n },\\n );\\n }\\n _ => buf.push(\\n match T::try_from_module_decl(decl.fold_children_with(self)) {\\n Ok(t) => t,\\n Err(..) => unreachable!(),\\n },\\n ),\\n };\\n }\\n Err(..) => unreachable!(),\\n },\\n Ok(stmt) => {\\n if first {\\n self.in_strict |= stmt.is_use_strict();\\n }\\n\\n let stmt = stmt.fold_children_with(self);\\n buf.push(T::from_stmt(stmt));\\n }\\n }\\n first = false;\\n }\\n\\n self.in_strict = old;\\n\\n buf\\n }\\n}\\n\\n#[fast_path(ClassFinder)]\\nimpl Fold for Classes\\nwhere\\n C: Comments,\\n{\\n noop_fold_type!();\\n\\n fn fold_module_items(&mut self, items: Vec) -> Vec {\\n self.fold_stmt_like(items)\\n }\\n\\n fn fold_stmts(&mut self, items: Vec) -> Vec {\\n self.fold_stmt_like(items)\\n }\\n\\n fn fold_decl(&mut self, n: Decl) -> Decl {\\n let n = match n {\\n Decl::Class(decl) => Decl::Var(self.fold_class_as_var_decl(decl.ident, decl.class)),\\n _ => n,\\n };\\n\\n n.fold_children_with(self)\\n }\\n\\n fn fold_expr(&mut self, n: Expr) -> Expr {\\n match n {\\n Expr::Class(e) => self.fold_class(e.ident, e.class).fold_children_with(self),\\n\\n _ => n.fold_children_with(self),\\n }\\n }\\n}\\n\\nimpl Classes\\nwhere\\n C: Comments,\\n{\\n fn fold_class_as_var_decl(&mut self, ident: Ident, class: Class) -> VarDecl {\\n let rhs = self.fold_class(Some(ident.clone()), class);\\n\\n VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Let,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n init: Some(Box::new(rhs)),\\n // Foo in var Foo =\\n name: ident.into(),\\n definite: false,\\n }],\\n declare: false,\\n }\\n }\\n\\n /// Turns class expression into iife.\\n ///\\n /// ```js\\n /// class Foo {}\\n /// ```\\n ///\\n /// ```js\\n /// function() {\\n /// var Foo = function Foo(){\\n /// };\\n /// }()\\n /// ```\\n fn fold_class(&mut self, class_name: Option, class: Class) -> Expr {\\n let span = class.span;\\n\\n // Ident of the super class *inside* function.\\n let super_ident = class\\n .super_class\\n .as_ref()\\n .map(|e| alias_if_required(e, \"_super\").0);\\n let has_super = super_ident.is_some();\\n let (params, args, super_ident) = if let Some(ref super_ident) = super_ident {\\n // Param should have a separate syntax context from arg.\\n let super_param = private_ident!(super_ident.sym.clone());\\n let params = vec![Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(super_param.clone().into()),\\n }];\\n\\n let super_class = class.super_class.clone().unwrap();\\n let is_super_native = match *super_class {\\n Expr::Ident(Ident { ref sym, .. }) => is_native(sym),\\n _ => false,\\n };\\n if is_super_native {\\n (\\n params,\\n vec![CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(wrap_native_super, \"wrapNativeSuper\"),\\n args: vec![super_class.as_arg()],\\n type_args: Default::default(),\\n }\\n .as_arg()],\\n Some(super_param),\\n )\\n } else {\\n (params, vec![super_class.as_arg()], Some(super_param))\\n }\\n } else {\\n (vec![], vec![], None)\\n };\\n\\n let mut stmts = self.class_to_stmts(class_name, super_ident, class);\\n\\n let cnt_of_non_directive = stmts\\n .iter()\\n .filter(|stmt| match stmt {\\n Stmt::Expr(ExprStmt { expr, .. }) => match &**expr {\\n Expr::Lit(Lit::Str(..)) => false,\\n _ => true,\\n },\\n _ => true,\\n })\\n .count();\\n if !has_super && cnt_of_non_directive == 1 {\\n // class Foo {}\\n //\\n // should be\\n //\\n // var Foo = function Foo() {\\n // _classCallCheck(this, Foo);\\n // };\\n //\\n // instead of\\n //\\n // var Foo = function(){\\n // function Foo() {\\n // _classCallCheck(this, Foo);\\n // }\\n //\\n // return Foo;\\n // }();\\n\\n let stmt = stmts.pop().unwrap();\\n match stmt {\\n Stmt::Decl(Decl::Fn(FnDecl {\\n ident,\\n mut function,\\n ..\\n })) => {\\n if let Some(use_strict) = stmts.pop() {\\n prepend(&mut function.body.as_mut().unwrap().stmts, use_strict);\\n }\\n return Expr::Fn(FnExpr {\\n ident: Some(ident),\\n function,\\n });\\n }\\n _ => unreachable!(),\\n }\\n }\\n\\n let body = BlockStmt {\\n span: DUMMY_SP,\\n stmts,\\n };\\n\\n let call = CallExpr {\\n span: DUMMY_SP,\\n callee: Expr::Fn(FnExpr {\\n ident: None,\\n function: Function {\\n span,\\n is_async: false,\\n is_generator: false,\\n params,\\n body: Some(body),\\n decorators: Default::default(),\\n type_params: Default::default(),\\n return_type: Default::default(),\\n },\\n })\\n .as_callee(),\\n args,\\n type_args: Default::default(),\\n };\\n if let Some(comments) = &self.comments {\\n comments.add_pure_comment(span.lo);\\n }\\n\\n Expr::Call(call)\\n }\\n\\n /// Returned `stmts` contains `return Foo`\\n fn class_to_stmts(\\n &mut self,\\n class_name: Option,\\n super_class_ident: Option,\\n class: Class,\\n ) -> Vec {\\n let class_name = class_name.unwrap_or_else(|| quote_ident!(\"_class\"));\\n let mut stmts = vec![];\\n\\n let mut priv_methods = vec![];\\n let mut methods = vec![];\\n let mut constructor = None;\\n for member in class.body {\\n match member {\\n ClassMember::Constructor(c) => {\\n if constructor.is_some() {\\n unimplemented!(\"multiple constructor\")\\n } else {\\n constructor = Some(c)\\n }\\n }\\n ClassMember::PrivateMethod(m) => priv_methods.push(m),\\n ClassMember::Method(m) => methods.push(m),\\n\\n ClassMember::ClassProp(..) => {\\n unreachable!(\"classes pass: property\\\\nclass_properties pass should remove this\")\\n }\\n ClassMember::PrivateProp(..) => unreachable!(\\n \"classes pass: private property\\\\nclass_properties pass should remove this\"\\n ),\\n ClassMember::TsIndexSignature(..) => {\\n // We just strip this.\\n }\\n ClassMember::Empty(..) => {}\\n ClassMember::StaticBlock(..) => unimplemented!(\"stage 3 class static blocks\"),\\n }\\n }\\n\\n if let Some(ref super_class_ident) = super_class_ident {\\n // inject helper methods\\n\\n stmts.push(\\n CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(inherits, \"inherits\"),\\n args: vec![\\n class_name.clone().as_arg(),\\n super_class_ident.clone().as_arg(),\\n ],\\n type_args: Default::default(),\\n }\\n .into_stmt(),\\n );\\n }\\n\\n // Marker for `_this`\\n let this_mark = Mark::fresh(Mark::root());\\n\\n {\\n // Process constructor\\n\\n let mut constructor =\\n constructor.unwrap_or_else(|| default_constructor(super_class_ident.is_some()));\\n\\n // Rename variables to avoid conflicting with class name\\n constructor.body = constructor.body.fold_with(&mut VarRenamer {\\n mark: Mark::fresh(Mark::root()),\\n class_name: &class_name.sym,\\n });\\n\\n // Black magic to detect injected constructor.\\n let is_constructor_default = constructor.span.is_dummy();\\n if is_constructor_default {\\n constructor.params = vec![];\\n }\\n\\n let mut insert_this = false;\\n\\n if super_class_ident.is_some() {\\n let (c, inserted_this) = replace_this_in_constructor(this_mark, constructor);\\n\\n constructor = c;\\n insert_this |= inserted_this;\\n }\\n\\n let mut body = constructor.body.unwrap().stmts;\\n // should we insert `var _this`?\\n\\n let is_always_initialized = is_always_initialized(&body);\\n\\n // We should handle branching\\n if !is_always_initialized {\\n insert_this = true;\\n }\\n\\n // inject possibleReturnCheck\\n let found_mode = SuperCallFinder::find(&body);\\n let mode = match found_mode {\\n None => None,\\n _ => {\\n if insert_this {\\n Some(SuperFoldingMode::Assign)\\n } else {\\n found_mode\\n }\\n }\\n };\\n\\n if super_class_ident.is_some() {\\n let this = quote_ident!(DUMMY_SP.apply_mark(this_mark), \"_this\");\\n\\n // We should fold body instead of constructor itself.\\n // Handle `super()`\\n body = body.fold_with(&mut ConstructorFolder {\\n is_constructor_default,\\n class_name: &class_name,\\n // This if expression is required to handle super() call in all case\\n mode: if insert_this {\\n Some(SuperFoldingMode::Assign)\\n } else {\\n mode\\n },\\n mark: this_mark,\\n ignore_return: false,\\n in_injected_define_property_call: false,\\n });\\n\\n insert_this |= (mode == None && !is_always_initialized)\\n || mode == Some(SuperFoldingMode::Assign);\\n\\n if insert_this {\\n prepend(\\n &mut body,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n declare: false,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(this.clone().into()),\\n init: None,\\n definite: false,\\n }],\\n })),\\n );\\n }\\n\\n let is_last_return = match body.last() {\\n Some(Stmt::Return(..)) => true,\\n _ => false,\\n };\\n if !is_last_return {\\n if is_always_initialized {\\n body.push(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(Box::new(Expr::Ident(this))),\\n }));\\n } else {\\n let possible_return_value =\\n Box::new(make_possible_return_value(ReturningMode::Returning {\\n mark: this_mark,\\n arg: None,\\n }));\\n body.push(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(possible_return_value),\\n }));\\n }\\n }\\n }\\n\\n let is_this_declared = (insert_this && super_class_ident.is_some())\\n || (mode == Some(SuperFoldingMode::Var));\\n\\n // Handle `super.XX`\\n body = self.handle_super_access(\\n &class_name,\\n body,\\n if is_this_declared {\\n Some(this_mark)\\n } else {\\n None\\n },\\n );\\n\\n // inject _classCallCheck(this, Bar);\\n inject_class_call_check(&mut body, class_name.clone());\\n\\n stmts.push(Stmt::Decl(Decl::Fn(FnDecl {\\n ident: class_name.clone(),\\n function: constructor_fn(Constructor {\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: body,\\n }),\\n ..constructor\\n }),\\n declare: false,\\n })));\\n }\\n\\n // convert class methods\\n // stmts.extend(self.fold_class_methods(class_name.clone(), priv_methods));\\n stmts.extend(self.fold_class_methods(class_name.clone(), methods));\\n\\n if stmts.first().map(|v| !v.is_use_strict()).unwrap_or(false) && !self.in_strict {\\n prepend(\\n &mut stmts,\\n Lit::Str(Str {\\n span: DUMMY_SP,\\n value: \"use strict\".into(),\\n has_escape: false,\\n kind: Default::default(),\\n })\\n .into_stmt(),\\n );\\n\\n if stmts.len() == 2 {\\n return stmts;\\n }\\n }\\n\\n if super_class_ident.is_none()\\n && stmts\\n .iter()\\n .filter(|stmt| match stmt {\\n Stmt::Expr(ExprStmt { expr, .. }) => match &**expr {\\n Expr::Lit(Lit::Str(..)) => false,\\n _ => true,\\n },\\n _ => true,\\n })\\n .count()\\n == 1\\n {\\n return stmts;\\n }\\n\\n // `return Foo`\\n stmts.push(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(Box::new(Expr::Ident(class_name))),\\n }));\\n\\n stmts\\n }\\n\\n ///\\n /// - `this_mark`: `Some(mark)` if we injected `var _this;`; otherwise\\n /// `None`\\n fn handle_super_access(\\n &mut self,\\n class_name: &Ident,\\n body: Vec,\\n this_mark: Option,\\n ) -> Vec {\\n let mut vars = vec![];\\n let mut folder = SuperFieldAccessFolder {\\n class_name,\\n vars: &mut vars,\\n constructor_this_mark: this_mark,\\n // constructor cannot be static\\n is_static: false,\\n folding_constructor: true,\\n in_nested_scope: false,\\n in_injected_define_property_call: false,\\n this_alias_mark: None,\\n };\\n\\n let mut body = body.fold_with(&mut folder);\\n\\n if let Some(mark) = folder.this_alias_mark {\\n prepend(\\n &mut body,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n declare: false,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(quote_ident!(DUMMY_SP.apply_mark(mark), \"_this\").into()),\\n init: Some(Box::new(Expr::This(ThisExpr { span: DUMMY_SP }))),\\n definite: false,\\n }],\\n })),\\n );\\n }\\n\\n if !vars.is_empty() {\\n prepend(\\n &mut body,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: vars,\\n })),\\n );\\n }\\n\\n body\\n }\\n\\n fn fold_class_methods(&mut self, class_name: Ident, methods: Vec) -> Vec {\\n if methods.is_empty() {\\n return vec![];\\n }\\n\\n /// { key: \"prop\" }\\n fn mk_key_prop(key: &PropName) -> Prop {\\n Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(key.span(), \"key\")),\\n value: match *key {\\n PropName::Ident(ref i) => {\\n Box::new(Expr::Lit(Lit::Str(quote_str!(i.span, i.sym.clone()))))\\n }\\n PropName::Str(ref s) => Box::new(Expr::Lit(Lit::Str(s.clone()))),\\n PropName::Num(n) => Box::new(Expr::Lit(Lit::Num(n))),\\n PropName::BigInt(ref b) => Box::new(Expr::Lit(Lit::BigInt(b.clone()))),\\n PropName::Computed(ref c) => c.expr.clone(),\\n },\\n })\\n }\\n\\n fn mk_arg_obj_for_create_class(props: IndexMap) -> ExprOrSpread {\\n if props.is_empty() {\\n return quote_expr!(DUMMY_SP, null).as_arg();\\n }\\n Expr::Array(ArrayLit {\\n span: DUMMY_SP,\\n elems: props\\n .into_iter()\\n .map(|(_, data)| {\\n let mut props = vec![PropOrSpread::Prop(data.key_prop)];\\n\\n macro_rules! add {\\n ($field:expr, $kind:expr, $s:literal) => {{\\n if let Some(value) = $field {\\n let value = escape_keywords(value);\\n props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(\\n KeyValueProp {\\n key: PropName::Ident(quote_ident!($s)),\\n value,\\n },\\n ))));\\n }\\n }};\\n }\\n\\n add!(data.get, MethodKind::Getter, \"get\");\\n add!(data.set, MethodKind::Setter, \"set\");\\n add!(data.method, MethodKind::Method, \"value\");\\n\\n ObjectLit {\\n span: DUMMY_SP,\\n props,\\n }\\n .as_arg()\\n })\\n .map(Some)\\n .collect(),\\n })\\n .as_arg()\\n }\\n\\n /// _createClass(Foo, [{}], [{}]);\\n fn mk_create_class_call(\\n class_name: Ident,\\n methods: ExprOrSpread,\\n static_methods: Option,\\n ) -> Stmt {\\n CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(create_class, \"createClass\"),\\n args: iter::once(class_name.as_arg())\\n .chain(iter::once(methods))\\n .chain(static_methods)\\n .collect(),\\n type_args: Default::default(),\\n }\\n .into_stmt()\\n }\\n\\n let (mut props, mut static_props) = (IndexMap::default(), IndexMap::default());\\n\\n for m in methods {\\n let key = HashKey::from(&m.key);\\n let key_prop = Box::new(mk_key_prop(&m.key));\\n let computed = match m.key {\\n PropName::Computed(..) => true,\\n _ => false,\\n };\\n let prop_name = prop_name_to_expr(m.key);\\n\\n let append_to: &mut IndexMap<_, _> = if m.is_static {\\n &mut static_props\\n } else {\\n &mut props\\n };\\n\\n let mut vars = vec![];\\n let mut folder = SuperFieldAccessFolder {\\n class_name: &class_name,\\n vars: &mut vars,\\n constructor_this_mark: None,\\n is_static: m.is_static,\\n folding_constructor: false,\\n in_nested_scope: false,\\n in_injected_define_property_call: false,\\n this_alias_mark: None,\\n };\\n let mut function = m.function.fold_with(&mut folder);\\n\\n if let Some(mark) = folder.this_alias_mark {\\n prepend(\\n &mut function.body.as_mut().unwrap().stmts,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n declare: false,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(\\n quote_ident!(DUMMY_SP.apply_mark(mark), \"_this\").into(),\\n ),\\n init: Some(Box::new(Expr::This(ThisExpr { span: DUMMY_SP }))),\\n definite: false,\\n }],\\n })),\\n );\\n }\\n\\n if !vars.is_empty() {\\n prepend(\\n &mut function.body.as_mut().unwrap().stmts,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: false,\\n decls: vars,\\n })),\\n );\\n }\\n\\n let value = Box::new(Expr::Fn(FnExpr {\\n ident: if m.kind == MethodKind::Method && !computed {\\n match prop_name {\\n Expr::Ident(ident) => Some(ident),\\n Expr::Lit(Lit::Str(Str { span, value, .. })) => {\\n Some(Ident::new(value, span))\\n }\\n _ => None,\\n }\\n } else {\\n None\\n },\\n function,\\n }));\\n\\n let data = append_to.entry(key).or_insert_with(|| Data {\\n key_prop,\\n get: None,\\n set: None,\\n method: None,\\n });\\n match m.kind {\\n MethodKind::Getter => data.get = Some(value),\\n MethodKind::Setter => data.set = Some(value),\\n MethodKind::Method => data.method = Some(value),\\n }\\n }\\n\\n if props.is_empty() && static_props.is_empty() {\\n return vec![];\\n }\\n vec![mk_create_class_call(\\n class_name,\\n mk_arg_obj_for_create_class(props),\\n if static_props.is_empty() {\\n None\\n } else {\\n Some(mk_arg_obj_for_create_class(static_props))\\n },\\n )]\\n }\\n}\\n\\nfn inject_class_call_check(c: &mut Vec, name: Ident) {\\n let class_call_check = CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(class_call_check, \"classCallCheck\"),\\n args: vec![\\n Expr::This(ThisExpr { span: DUMMY_SP }).as_arg(),\\n Expr::Ident(name).as_arg(),\\n ],\\n type_args: Default::default(),\\n }\\n .into_stmt();\\n\\n prepend(c, class_call_check)\\n}\\n\\n/// Returns true if no `super` is used before `super()` call.\\nfn is_always_initialized(body: &[Stmt]) -> bool {\\n struct SuperFinder {\\n found: bool,\\n }\\n\\n impl Visit for SuperFinder {\\n noop_visit_type!();\\n\\n fn visit_expr_or_super(&mut self, node: &ExprOrSuper, _: &dyn Node) {\\n match *node {\\n ExprOrSuper::Super(..) => self.found = true,\\n _ => node.visit_children_with(self),\\n }\\n }\\n }\\n\\n let pos = match body.iter().position(|s| match s {\\n Stmt::Expr(ExprStmt { expr, .. }) => match &**expr {\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Super(..),\\n ..\\n }) => true,\\n\\n _ => false,\\n },\\n _ => false,\\n }) {\\n Some(pos) => pos,\\n _ => return false,\\n };\\n\\n let mut v = SuperFinder { found: false };\\n let body = &body[..pos];\\n\\n v.visit_stmts(body, &Invalid { span: DUMMY_SP });\\n\\n if v.found {\\n return false;\\n }\\n\\n true\\n}\\n\\nfn escape_keywords(mut e: Box) -> Box {\\n match &mut *e {\\n Expr::Fn(f) => {\\n if let Some(i) = &mut f.ident {\\n if i.is_reserved()\\n || i.is_reserved_in_strict_mode(true)\\n || i.is_reserved_in_strict_bind()\\n {\\n i.sym = format!(\"_{}\", i.sym).into();\\n }\\n }\\n }\\n _ => {}\\n }\\n\\n e\\n}\\n\\n#[derive(Default)]\\nstruct ClassFinder {\\n found: bool,\\n}\\n\\nimpl Visit for ClassFinder {\\n noop_visit_type!();\\n\\n fn visit_class(&mut self, _: &Class, _: &dyn Node) {\\n self.found = true\\n }\\n}\\n\\nimpl Check for ClassFinder {\\n fn should_handle(&self) -> bool {\\n self.found\\n }\\n}\\n',\n", + " 'content_id': 'e90a6e352e451e890182a612a7b5a538d290e8a4',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/transforms/compat/src/es2015/classes/mod.rs',\n", + " 'size': 31308,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6147082334132694,\n", + " 'avg_line_length': 35.794117647058826,\n", + " 'blob_id': '85e2d5f86914f0987a5f27640efdea9d22a2a2ce',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"preset-env for the swc\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_preset_env/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_preset_env\"\\nversion = \"0.51.0\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\ndashmap = \"4.0.2\"\\nindexmap = \"1.6.2\"\\nonce_cell = \"1.2.0\"\\nrustc-hash = \"1.1.0\"\\nsemver = {version = \"0.9.0\", features = [\"serde\"]}\\nserde = {version = \"1\", features = [\"derive\"]}\\nserde_json = \"1\"\\nst-map = \"0.1.2\"\\nstring_enum = {version = \"0.3.1\", path = \"../../macros/string_enum\"}\\nswc_atoms = {version = \"0.2\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_transforms = {version = \"0.80.0\", path = \"../transforms\", features = [\"compat\", \"proposal\"]}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../visit\"}\\nwalkdir = \"2\"\\n\\n[dev-dependencies]\\npretty_assertions = \"0.6\"\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../codegen\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../parser\"}\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\n',\n", + " 'content_id': 'f5c627f34a6c02b6938580f876f250f3d8f78190',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 101,\n", + " 'path': '/ecmascript/preset-env/Cargo.toml',\n", + " 'size': 1251,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4459274988624298,\n", + " 'avg_line_length': 34.9291553133515,\n", + " 'blob_id': 'eacdd8821d8a0b64b2dadc6a1cbe80b3dc9d56a2',\n", + " 'content': '//! Faster version of node-resolve.\\n//!\\n//! See: https://github.com/goto-bus-stop/node-resolve\\n\\nuse crate::{resolve::Resolve, NODE_BUILTINS};\\nuse anyhow::{bail, Context, Error};\\n#[cfg(windows)]\\nuse normpath::BasePath;\\nuse path_clean::PathClean;\\nuse rustc_hash::FxHashMap;\\nuse serde::Deserialize;\\nuse std::{\\n fs::File,\\n io::BufReader,\\n path::{Component, Path, PathBuf},\\n};\\nuse swc_common::FileName;\\nuse swc_ecma_ast::TargetEnv;\\nuse tracing::debug;\\n\\nuse dashmap::{DashMap, DashSet};\\nuse once_cell::sync::Lazy;\\n\\nstatic PACKAGE: &str = \"package.json\";\\n\\n/// Map of cached `browser` fields from deserialized package.json\\n/// used to determine if we need to map to alternative paths when\\n/// bundling for the browser runtime environment. The key is the\\n/// directory containing the package.json file which is important\\n/// to ensure we only apply these `browser` rules to modules in\\n/// the owning package.\\nstatic BROWSER_CACHE: Lazy> = Lazy::new(Default::default);\\n\\n#[derive(Debug, Default)]\\nstruct BrowserCache {\\n rewrites: DashMap,\\n ignores: DashSet,\\n module_rewrites: DashMap,\\n module_ignores: DashSet,\\n}\\n\\n/// Helper to find the nearest `package.json` file to get\\n/// the base directory for a package.\\nfn find_package_root(path: &PathBuf) -> Option {\\n let mut parent = path.parent();\\n while let Some(p) = parent {\\n let pkg = p.join(PACKAGE);\\n if pkg.is_file() {\\n return Some(p.to_path_buf());\\n }\\n parent = p.parent();\\n }\\n None\\n}\\n\\npub(crate) fn is_core_module(s: &str) -> bool {\\n NODE_BUILTINS.contains(&s)\\n}\\n\\n#[derive(Deserialize)]\\nstruct PackageJson {\\n #[serde(default)]\\n main: Option,\\n #[serde(default)]\\n browser: Option,\\n}\\n\\n#[derive(Deserialize)]\\n#[serde(untagged)]\\nenum Browser {\\n Str(String),\\n Obj(FxHashMap),\\n}\\n\\n#[derive(Deserialize, Clone)]\\n#[serde(untagged)]\\nenum StringOrBool {\\n Str(String),\\n Bool(bool),\\n}\\n\\n#[derive(Debug, Default)]\\npub struct NodeModulesResolver {\\n target_env: TargetEnv,\\n alias: FxHashMap,\\n}\\n\\nstatic EXTENSIONS: &[&str] = &[\"ts\", \"tsx\", \"js\", \"jsx\", \"json\", \"node\"];\\n\\nimpl NodeModulesResolver {\\n /// Create a node modules resolver for the target runtime environment.\\n pub fn new(target_env: TargetEnv, alias: FxHashMap) -> Self {\\n Self { target_env, alias }\\n }\\n\\n fn wrap(&self, path: Option) -> Result {\\n if let Some(path) = path {\\n let path = path.clean();\\n return Ok(FileName::Real(path));\\n }\\n bail!(\"index not found\")\\n }\\n\\n /// Resolve a path as a file. If `path` refers to a file, it is returned;\\n /// otherwise the `path` + each extension is tried.\\n fn resolve_as_file(&self, path: &Path) -> Result, Error> {\\n if path.is_file() {\\n return Ok(Some(path.to_path_buf()));\\n }\\n\\n if let Some(name) = path.file_name() {\\n let mut ext_path = path.to_path_buf();\\n let name = name.to_string_lossy();\\n for ext in EXTENSIONS {\\n ext_path.set_file_name(format!(\"{}.{}\", name, ext));\\n if ext_path.is_file() {\\n return Ok(Some(ext_path));\\n }\\n }\\n }\\n\\n bail!(\"file not found: {}\", path.display())\\n }\\n\\n /// Resolve a path as a directory, using the \"main\" key from a package.json\\n /// file if it exists, or resolving to the index.EXT file if it exists.\\n fn resolve_as_directory(&self, path: &PathBuf) -> Result, Error> {\\n let pkg_path = path.join(PACKAGE);\\n if pkg_path.is_file() {\\n if let Some(main) = self.resolve_package_entry(path, &pkg_path)? {\\n return Ok(Some(main));\\n }\\n }\\n\\n // Try to resolve to an index file.\\n for ext in EXTENSIONS {\\n let ext_path = path.join(format!(\"index.{}\", ext));\\n if ext_path.is_file() {\\n return Ok(Some(ext_path));\\n }\\n }\\n Ok(None)\\n }\\n\\n /// Resolve using the package.json \"main\" or \"browser\" keys.\\n fn resolve_package_entry(\\n &self,\\n pkg_dir: &PathBuf,\\n pkg_path: &PathBuf,\\n ) -> Result, Error> {\\n let file = File::open(pkg_path)?;\\n let reader = BufReader::new(file);\\n let pkg: PackageJson = serde_json::from_reader(reader)\\n .context(format!(\"failed to deserialize {}\", pkg_path.display()))?;\\n\\n let main_fields = match self.target_env {\\n TargetEnv::Node => {\\n vec![pkg.main.as_ref().clone()]\\n }\\n TargetEnv::Browser => {\\n if let Some(browser) = &pkg.browser {\\n match browser {\\n Browser::Str(path) => {\\n vec![Some(path), pkg.main.as_ref().clone()]\\n }\\n Browser::Obj(map) => {\\n let bucket = BROWSER_CACHE.entry(pkg_dir.to_path_buf()).or_default();\\n\\n for (k, v) in map {\\n let target_key = Path::new(k);\\n let mut components = target_key.components();\\n\\n // Relative file paths are sources for this package\\n let source = if let Some(Component::CurDir) = components.next() {\\n let path = pkg_dir.join(k);\\n if let Ok(file) = self\\n .resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path))\\n {\\n file\\n } else {\\n None\\n }\\n } else {\\n None\\n };\\n\\n match v {\\n StringOrBool::Str(dest) => {\\n let path = pkg_dir.join(dest);\\n let file = self\\n .resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path))?;\\n if let Some(file) = file {\\n let target = file.clean();\\n\\n if let Some(source) = source {\\n bucket.rewrites.insert(source, target);\\n } else {\\n bucket.module_rewrites.insert(k.clone(), target);\\n }\\n }\\n }\\n StringOrBool::Bool(flag) => {\\n // If somebody set boolean `true` which is an\\n // invalid value we will just ignore it\\n if !flag {\\n if let Some(source) = source {\\n bucket.ignores.insert(source);\\n } else {\\n bucket.module_ignores.insert(k.clone());\\n }\\n }\\n }\\n }\\n }\\n vec![pkg.main.as_ref().clone()]\\n }\\n }\\n } else {\\n vec![pkg.main.as_ref().clone()]\\n }\\n }\\n };\\n\\n for main in main_fields {\\n if let Some(target) = main {\\n let path = pkg_dir.join(target);\\n return self\\n .resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path));\\n }\\n }\\n\\n Ok(None)\\n }\\n\\n /// Resolve by walking up node_modules folders.\\n fn resolve_node_modules(\\n &self,\\n base_dir: &Path,\\n target: &str,\\n ) -> Result, Error> {\\n let mut path = Some(base_dir);\\n while let Some(dir) = path {\\n let node_modules = dir.join(\"node_modules\");\\n if node_modules.is_dir() {\\n let path = node_modules.join(target);\\n if let Some(result) = self\\n .resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path))?\\n {\\n return Ok(Some(result));\\n }\\n }\\n path = dir.parent();\\n }\\n\\n Ok(None)\\n }\\n}\\n\\nimpl Resolve for NodeModulesResolver {\\n fn resolve(&self, base: &FileName, target: &str) -> Result {\\n debug!(\\n \"Resolve {} from {:#?} for {:#?}\",\\n target, base, self.target_env\\n );\\n\\n let base = match base {\\n FileName::Real(v) => v,\\n _ => bail!(\"node-resolver supports only files\"),\\n };\\n\\n let base_dir = if base.is_file() {\\n let cwd = &Path::new(\".\");\\n base.parent().unwrap_or(&cwd)\\n } else {\\n base\\n };\\n\\n // Handle module references for the `browser` package config\\n // before we map aliases.\\n if let TargetEnv::Browser = self.target_env {\\n if let Some(pkg_base) = find_package_root(base) {\\n if let Some(item) = BROWSER_CACHE.get(&pkg_base) {\\n let value = item.value();\\n if value.module_ignores.contains(target) {\\n return Ok(FileName::Custom(target.into()));\\n }\\n if let Some(rewrite) = value.module_rewrites.get(target) {\\n return self.wrap(Some(rewrite.to_path_buf()));\\n }\\n }\\n }\\n }\\n\\n // Handle builtin modules for nodejs\\n if let TargetEnv::Node = self.target_env {\\n if is_core_module(target) {\\n return Ok(FileName::Custom(format!(\"node:{}\", target.to_string())));\\n }\\n }\\n\\n // Aliases allow browser shims to be renamed so we can\\n // map `stream` to `stream-browserify` for example\\n let target = if let Some(alias) = self.alias.get(target) {\\n &alias[..]\\n } else {\\n target\\n };\\n\\n let target_path = Path::new(target);\\n\\n let file_name = {\\n if target_path.is_absolute() {\\n let path = PathBuf::from(target_path);\\n self.resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path))\\n .and_then(|p| self.wrap(p))\\n } else {\\n let mut components = target_path.components();\\n\\n if let Some(Component::CurDir | Component::ParentDir) = components.next() {\\n #[cfg(windows)]\\n let path = {\\n let base_dir = BasePath::new(base_dir).unwrap();\\n base_dir\\n .join(target.replace(\\'/\\', \"\\\\\\\\\"))\\n .normalize_virtually()\\n .unwrap()\\n .into_path_buf()\\n };\\n #[cfg(not(windows))]\\n let path = base_dir.join(target);\\n self.resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path))\\n .and_then(|p| self.wrap(p))\\n } else {\\n self.resolve_node_modules(base_dir, target)\\n .and_then(|p| self.wrap(p))\\n }\\n }\\n }\\n .and_then(|v| {\\n // Handle path references for the `browser` package config\\n if let TargetEnv::Browser = self.target_env {\\n if let FileName::Real(path) = &v {\\n if let Some(pkg_base) = find_package_root(base) {\\n if let Some(item) = BROWSER_CACHE.get(&pkg_base) {\\n let value = item.value();\\n if value.ignores.contains(path) {\\n return Ok(FileName::Custom(path.display().to_string().into()));\\n }\\n if let Some(rewrite) = value.rewrites.get(path) {\\n return self.wrap(Some(rewrite.to_path_buf()));\\n }\\n }\\n }\\n }\\n }\\n Ok(v)\\n });\\n\\n file_name\\n }\\n}\\n',\n", + " 'content_id': '4ae0d6079f695127b233182720704308bf5352eb',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 97,\n", + " 'path': '/ecmascript/loader/src/resolvers/node.rs',\n", + " 'size': 13186,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6121024049650892,\n", + " 'avg_line_length': 25.854166666666668,\n", + " 'blob_id': '54c2b0410f7968307a4f240743de693ef93be756',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Feature-complete es2019 parser.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_parser/\"\\nedition = \"2018\"\\ninclude = [\"Cargo.toml\", \"src/**/*.rs\", \"examples/**/*.rs\"]\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_parser\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.73.3\"\\n\\n[package.metadata.docs.rs]\\nall-features = true\\n\\n[features]\\n# Used for debugging\\ndebug = []\\ndefault = [\"typescript\"]\\ntypescript = []\\n\\n[dependencies]\\neither = {version = \"1.4\"}\\nenum_kind = {version = \"0.2.1\", path = \"../../macros/enum_kind\"}\\nlexical = {version = \"5.2.2\", features = [\"radix\"]}\\nnum-bigint = \"0.2\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1\", features = [\"derive\"]}\\nsmallvec = \"1\"\\nswc_atoms = {version = \"0.2.3\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../visit\"}\\ntracing = \"0.1.28\"\\nunicode-xid = \"0.2\"\\n\\n[dev-dependencies]\\nenv_logger = \"0.7\"\\npretty_assertions = \"0.6\"\\nserde_json = \"1\"\\nswc_node_base = {version = \"0.4.0\", path = \"../../node/base\"}\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\nwalkdir = \"2\"\\n\\n[[example]]\\nname = \"lexer\"\\n\\n[[example]]\\nname = \"typescript\"\\n',\n", + " 'content_id': 'e84dc459f1399b363337c32d9d64830f839a51cf',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 64,\n", + " 'path': '/ecmascript/parser/Cargo.toml',\n", + " 'size': 1289,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4541978141267609,\n", + " 'avg_line_length': 32.38797364085667,\n", + " 'blob_id': '16faef2c80f70ce1595dbb9910915682df5ca248',\n", + " 'content': '//! The main crate of the swc project.\\n//!\\n//!\\n//!\\n//! # Cutomizing\\n//!\\n//!\\n//! This is documentation for building custom build tools on top of swc.\\n//!\\n//! ## Dependency version management\\n//!\\n//! `swc` has [swc_emcascript](https://docs.rs/swc_emcascript) and [swc_css](https://docs.rs/swc_css), which re-exports required modules.\\n//!\\n//! ## Testing\\n//!\\n//! See [testing] and [swc_ecmc_transform_testing](https://docs.rs/swc_ecmc_transform_testing).\\n//!\\n//! ## Custom javascript transforms\\n//!\\n//!\\n//!\\n//! ### What is [JsWord](swc_atoms::JsWord)?\\n//!\\n//! It\\'s basically an interned string. See [swc_atoms].\\n//!\\n//! ### Choosing between [JsWord](swc_atoms::JsWord) vs String\\n//!\\n//! You should prefer [JsWord](swc_atoms::JsWord) over [String] if it\\'s going\\n//! to be stored in an AST node.\\n//!\\n//! See [swc_atoms] for detailed description.\\n//!\\n//! ### Fold vs VisitMut vs Visit\\n//!\\n//! See [swc_visit] for detailed description.\\n//!\\n//!\\n//! - [Fold](swc_ecma_visit::Fold)\\n//! - [VisitMut](swc_ecma_visit::VisitMut)\\n//! - [Visit](swc_ecma_visit::Visit)\\n//!\\n//!\\n//! ### Variable management (Scoping)\\n//!\\n//! See [swc_ecma_transforms_base::resolver::resolver_with_mark].\\n//!\\n//! #### How identifiers work\\n//!\\n//! See the doc on [swc_ecma_ast::Ident] or on\\n//! [swc_ecma_transforms_base::resolver::resolver_with_mark].\\n//!\\n//! #### Comparing two identifiers\\n//!\\n//! See [swc_ecma_utils::Id]. You can use [swc_ecma_utils::IdentLike::to_id] to\\n//! extract important parts of an [swc_ecma_ast::Ident].\\n//!\\n//! #### Creating a unique identifier\\n//!\\n//! See [swc_ecma_utils::private_ident].\\n//!\\n//! #### Prepending statements\\n//!\\n//! If you want to prepend statements to the beginning of a file, you can use\\n//! [swc_ecma_utils::prepend_stmts] or [swc_ecma_utils::prepend] if `len == 1`.\\n//!\\n//! These methods are aware of the fact that `\"use strict\"` directive should be\\n//! first in a file, and insert statements after directives.\\n//!\\n//! ### Improving readability\\n//!\\n//! Each stuffs are documented at itself.\\n//!\\n//! - If you are creating or binding an [swc_ecma_ast::Expr] with operator, you\\n//! can use [swc_ecma_ast::op].\\n//!\\n//! - If you want to create [swc_ecma_ast::CallExpr], you can use\\n//! [swc_ecma_utils::ExprFactory::as_callee] to create `callee`.\\n//!\\n//! - If you want to create [swc_ecma_ast::CallExpr] or\\n//! [swc_ecma_ast::NewExpr], you can use\\n//! [swc_ecma_utils::ExprFactory::as_arg] to create arguments.\\n//!\\n//!\\n//! - If you want to create [swc_ecma_ast::MemberExpr] where all identifiers\\n//! are static (e.g. `Object.prototype.hasOwnProperty`), you can use\\n//! [swc_ecma_utils::member_expr].\\n//!\\n//! - If you want to create [swc_ecma_ast::MemberExpr], you can use\\n//! [swc_ecma_utils::ExprFactory::as_obj] to create object field.\\n//!\\n//!\\n//! ### Reducing binary size\\n//!\\n//! The visitor expands to a lot of code. You can reduce it by using macros like\\n//!\\n//! - [noop_fold_type](swc_ecma_visit::noop_fold_type)\\n//! - [noop_visit_mut_type](swc_ecma_visit::noop_visit_mut_type)\\n//! - [noop_visit_type](swc_ecma_visit::noop_visit_type)\\n//!\\n//! Note that this will make typescript-related nodes not processed, but it\\'s\\n//! typically fine as `typescript::strip` is invoked at the start and it removes\\n//! typescript-specific nodes.\\n//!\\n//! ### Porting `expr.evaluate()` of babel\\n//!\\n//! See [swc_ecma_minifier::eval::Evaluator].\\n#![deny(unused)]\\n\\npub extern crate swc_atoms as atoms;\\npub extern crate swc_common as common;\\npub extern crate swc_ecmascript as ecmascript;\\n\\npub use crate::builder::PassBuilder;\\nuse crate::config::{\\n BuiltConfig, Config, ConfigFile, InputSourceMap, JscTarget, Merge, Options, Rc, RootMode,\\n SourceMapsConfig,\\n};\\nuse anyhow::{bail, Context, Error};\\nuse atoms::JsWord;\\nuse config::{util::BoolOrObject, JsMinifyCommentOption, JsMinifyOptions};\\nuse dashmap::DashMap;\\nuse once_cell::sync::Lazy;\\nuse serde::Serialize;\\nuse serde_json::error::Category;\\npub use sourcemap;\\nuse std::{\\n fs::{read_to_string, File},\\n io::Write,\\n mem::take,\\n path::{Path, PathBuf},\\n sync::{Arc, Mutex},\\n};\\nuse swc_common::{\\n chain,\\n comments::{Comment, CommentKind, Comments},\\n errors::Handler,\\n input::StringInput,\\n source_map::SourceMapGenConfig,\\n sync::Lrc,\\n BytePos, FileName, Globals, Mark, SourceFile, SourceMap, Spanned, DUMMY_SP, GLOBALS,\\n};\\nuse swc_ecma_ast::{Ident, Invalid, Program};\\nuse swc_ecma_codegen::{self, text_writer::WriteJs, Emitter, Node};\\nuse swc_ecma_loader::resolvers::{\\n lru::CachingResolver, node::NodeModulesResolver, tsc::TsConfigResolver,\\n};\\nuse swc_ecma_minifier::option::MinifyOptions;\\nuse swc_ecma_parser::{lexer::Lexer, EsConfig, Parser, Syntax};\\nuse swc_ecma_transforms::{\\n fixer,\\n helpers::{self, Helpers},\\n hygiene,\\n modules::path::NodeImportResolver,\\n pass::noop,\\n resolver_with_mark,\\n};\\nuse swc_ecma_visit::{noop_visit_type, FoldWith, Visit, VisitWith};\\n\\nmod builder;\\npub mod config;\\npub mod resolver {\\n use crate::config::CompiledPaths;\\n use rustc_hash::FxHashMap;\\n use std::path::PathBuf;\\n use swc_ecma_ast::TargetEnv;\\n use swc_ecma_loader::resolvers::{\\n lru::CachingResolver, node::NodeModulesResolver, tsc::TsConfigResolver,\\n };\\n\\n pub type NodeResolver = CachingResolver;\\n\\n pub fn paths_resolver(\\n target_env: TargetEnv,\\n alias: FxHashMap,\\n base_url: PathBuf,\\n paths: CompiledPaths,\\n ) -> CachingResolver> {\\n let r = TsConfigResolver::new(NodeModulesResolver::new(target_env, alias), base_url, paths);\\n CachingResolver::new(40, r)\\n }\\n\\n pub fn environment_resolver(\\n target_env: TargetEnv,\\n alias: FxHashMap,\\n ) -> NodeResolver {\\n CachingResolver::new(40, NodeModulesResolver::new(target_env, alias))\\n }\\n}\\n\\n#[derive(Clone, Default)]\\nstruct LockedWriter(Arc>>);\\n\\nimpl Write for LockedWriter {\\n fn write(&mut self, buf: &[u8]) -> std::io::Result {\\n let mut lock = self\\n .0\\n .lock()\\n .expect(\"failed to get lock while trying to report error\");\\n\\n lock.extend_from_slice(buf);\\n\\n Ok(buf.len())\\n }\\n\\n fn flush(&mut self) -> std::io::Result<()> {\\n Ok(())\\n }\\n}\\n\\n/// Try operation with a [Handler] and prints the errors as a [String] wrapped\\n/// by [Err].\\npub fn try_with_handler(cm: Lrc, op: F) -> Result\\nwhere\\n F: FnOnce(&Handler) -> Result,\\n{\\n let wr = Box::new(LockedWriter::default());\\n\\n let handler = Handler::with_emitter_writer(wr.clone(), Some(cm.clone()));\\n\\n let ret = swc_ecma_utils::HANDLER.set(&handler, || op(&handler));\\n\\n if handler.has_errors() {\\n let mut lock =\\n wr.0.lock()\\n .expect(\"reference to handler should not exist in this point\");\\n let error = take(&mut *lock);\\n\\n let msg = String::from_utf8(error).expect(\"error string should be utf8\");\\n\\n match ret {\\n Ok(_) => Err(anyhow::anyhow!(msg)),\\n Err(err) => Err(err.context(msg)),\\n }\\n } else {\\n ret\\n }\\n}\\n\\ntype SwcImportResolver =\\n Arc>>>;\\n\\n/// All methods accept [Handler], which is a storage for errors.\\n///\\n/// The caller should check if the handler contains any errors after calling\\n/// method.\\npub struct Compiler {\\n /// swc uses rustc\\'s span interning.\\n ///\\n /// The `Globals` struct contains span interner.\\n globals: Globals,\\n /// CodeMap\\n pub cm: Arc,\\n comments: SwcComments,\\n}\\n\\n#[derive(Debug, Serialize)]\\npub struct TransformOutput {\\n pub code: String,\\n #[serde(skip_serializing_if = \"Option::is_none\")]\\n pub map: Option,\\n}\\n\\n/// These are **low-level** apis.\\nimpl Compiler {\\n pub fn globals(&self) -> &Globals {\\n &self.globals\\n }\\n\\n pub fn comments(&self) -> &SwcComments {\\n &self.comments\\n }\\n\\n /// Runs `op` in current compiler\\'s context.\\n ///\\n /// Note: Other methods of `Compiler` already uses this internally.\\n pub fn run(&self, op: F) -> R\\n where\\n F: FnOnce() -> R,\\n {\\n GLOBALS.set(&self.globals, || op())\\n }\\n\\n fn get_orig_src_map(\\n &self,\\n fm: &SourceFile,\\n input_src_map: &InputSourceMap,\\n is_default: bool,\\n ) -> Result, Error> {\\n self.run(|| -> Result<_, Error> {\\n let name = &fm.name;\\n\\n // Load original source map\\n match input_src_map {\\n InputSourceMap::Bool(false) => Ok(None),\\n InputSourceMap::Bool(true) => {\\n let s = \"sourceMappingURL=\";\\n let idx = fm.src.rfind(s);\\n let src_mapping_url = match idx {\\n None => None,\\n Some(idx) => Some(&fm.src[idx + s.len()..]),\\n };\\n\\n // Load original source map if possible\\n match &name {\\n FileName::Real(filename) => {\\n let dir = match filename.parent() {\\n Some(v) => v,\\n None => {\\n bail!(\"unexpected: root directory is given as a input file\")\\n }\\n };\\n\\n let path = match src_mapping_url {\\n Some(src_mapping_url) => {\\n dir.join(src_mapping_url).display().to_string()\\n }\\n None => {\\n format!(\"{}.map\", dir.join(filename).display())\\n }\\n };\\n\\n let file = File::open(&path)\\n .or_else(|err| {\\n // Old behavior. This check would prevent regressions.\\n let f = format!(\"{}.map\", filename.display());\\n\\n match File::open(&f) {\\n Ok(v) => Ok(v),\\n Err(_) => Err(err),\\n }\\n })\\n .context(\"failed to open input source map file\");\\n\\n let file = if !is_default {\\n file?\\n } else {\\n match file {\\n Ok(v) => v,\\n Err(_) => return Ok(None),\\n }\\n };\\n\\n Ok(Some(sourcemap::SourceMap::from_reader(file).with_context(\\n || format!(\"failed to read input source map from file at {}\", path),\\n )?))\\n }\\n _ => {\\n tracing::error!(\"Failed to load source map for non-file input\");\\n return Ok(None);\\n }\\n }\\n }\\n InputSourceMap::Str(ref s) => {\\n if s == \"inline\" {\\n // Load inline source map by simple string\\n // operations\\n let s = \"sourceMappingURL=data:application/json;base64,\";\\n let idx = fm.src.rfind(s);\\n let idx = match idx {\\n None => bail!(\\n \"failed to parse inline source map: `sourceMappingURL` not found\"\\n ),\\n Some(v) => v,\\n };\\n let encoded = &fm.src[idx + s.len()..];\\n\\n let res = base64::decode(encoded.as_bytes())\\n .context(\"failed to decode base64-encoded source map\")?;\\n\\n Ok(Some(sourcemap::SourceMap::from_slice(&res).context(\\n \"failed to read input source map from inlined base64 encoded string\",\\n )?))\\n } else {\\n // Load source map passed by user\\n Ok(Some(\\n sourcemap::SourceMap::from_slice(s.as_bytes()).context(\\n \"failed to read input source map from user-provided sourcemap\",\\n )?,\\n ))\\n }\\n }\\n }\\n })\\n }\\n\\n /// This method parses a javascript / typescript file\\n pub fn parse_js(\\n &self,\\n fm: Arc,\\n handler: &Handler,\\n target: JscTarget,\\n syntax: Syntax,\\n is_module: bool,\\n parse_comments: bool,\\n ) -> Result {\\n self.run(|| {\\n let lexer = Lexer::new(\\n syntax,\\n target,\\n StringInput::from(&*fm),\\n if parse_comments {\\n Some(&self.comments)\\n } else {\\n None\\n },\\n );\\n let mut parser = Parser::new_from(lexer);\\n let mut error = false;\\n let program = if is_module {\\n let m = parser.parse_module();\\n\\n for e in parser.take_errors() {\\n e.into_diagnostic(handler).emit();\\n error = true;\\n }\\n\\n m.map_err(|e| {\\n e.into_diagnostic(handler).emit();\\n Error::msg(\"failed to parse module\")\\n })\\n .map(Program::Module)?\\n } else {\\n let s = parser.parse_script();\\n\\n for e in parser.take_errors() {\\n e.into_diagnostic(handler).emit();\\n error = true;\\n }\\n\\n s.map_err(|e| {\\n e.into_diagnostic(handler).emit();\\n Error::msg(\"failed to parse module\")\\n })\\n .map(Program::Script)?\\n };\\n\\n if error {\\n bail!(\\n \"failed to parse module: error was recoverable, but proceeding would result \\\\\\n in wrong codegen\"\\n )\\n }\\n\\n Ok(program)\\n })\\n }\\n\\n /// Converts ast node to source string and sourcemap.\\n ///\\n ///\\n /// This method receives target file path, but does not write file to the\\n /// path. See: https://github.com/swc-project/swc/issues/1255\\n pub fn print(\\n &self,\\n node: &T,\\n source_file_name: Option<&str>,\\n output_path: Option,\\n inline_sources_content: bool,\\n target: JscTarget,\\n source_map: SourceMapsConfig,\\n source_map_names: &[JsWord],\\n orig: Option<&sourcemap::SourceMap>,\\n minify: bool,\\n preserve_comments: Option>,\\n ) -> Result\\n where\\n T: Node + VisitWith,\\n {\\n self.run(|| {\\n let preserve_comments = preserve_comments.unwrap_or_else(|| {\\n if minify {\\n BoolOrObject::Obj(JsMinifyCommentOption::PreserveSomeComments)\\n } else {\\n BoolOrObject::Obj(JsMinifyCommentOption::PreserveAllComments)\\n }\\n });\\n\\n let span = node.span();\\n\\n match preserve_comments {\\n BoolOrObject::Bool(true)\\n | BoolOrObject::Obj(JsMinifyCommentOption::PreserveAllComments) => {}\\n\\n BoolOrObject::Obj(JsMinifyCommentOption::PreserveSomeComments) => {\\n let preserve_excl = |pos: &BytePos, vc: &mut Vec| -> bool {\\n if *pos < span.lo || *pos >= span.hi {\\n return true;\\n }\\n\\n // Preserve license comments.\\n if vc.iter().any(|c| c.text.contains(\"@license\")) {\\n return true;\\n }\\n\\n vc.retain(|c: &Comment| c.text.starts_with(\"!\"));\\n !vc.is_empty()\\n };\\n self.comments.leading.retain(preserve_excl);\\n self.comments.trailing.retain(preserve_excl);\\n }\\n\\n BoolOrObject::Bool(false) => {\\n let remove_all_in_range = |pos: &BytePos, _: &mut Vec| -> bool {\\n if *pos < span.lo || *pos >= span.hi {\\n return true;\\n }\\n\\n false\\n };\\n self.comments.leading.retain(remove_all_in_range);\\n self.comments.trailing.retain(remove_all_in_range);\\n }\\n }\\n\\n let mut src_map_buf = vec![];\\n\\n let src = {\\n let mut buf = vec![];\\n {\\n let mut wr = Box::new(swc_ecma_codegen::text_writer::JsWriter::with_target(\\n self.cm.clone(),\\n \"\\\\n\",\\n &mut buf,\\n if source_map.enabled() {\\n Some(&mut src_map_buf)\\n } else {\\n None\\n },\\n target,\\n )) as Box;\\n\\n if minify {\\n wr = Box::new(swc_ecma_codegen::text_writer::omit_trailing_semi(wr));\\n }\\n\\n let mut emitter = Emitter {\\n cfg: swc_ecma_codegen::Config { minify },\\n comments: if minify { None } else { Some(&self.comments) },\\n cm: self.cm.clone(),\\n wr,\\n };\\n\\n node.emit_with(&mut emitter)\\n .context(\"failed to emit module\")?;\\n }\\n // Invalid utf8 is valid in javascript world.\\n String::from_utf8(buf).expect(\"invalid utf8 characeter detected\")\\n };\\n let (code, map) = match source_map {\\n SourceMapsConfig::Bool(v) => {\\n if v {\\n let mut buf = vec![];\\n\\n self.cm\\n .build_source_map_with_config(\\n &mut src_map_buf,\\n orig,\\n SwcSourceMapConfig {\\n source_file_name,\\n output_path: output_path.as_deref(),\\n names: source_map_names,\\n inline_sources_content,\\n },\\n )\\n .to_writer(&mut buf)\\n .context(\"failed to write source map\")?;\\n let map = String::from_utf8(buf).context(\"source map is not utf-8\")?;\\n (src, Some(map))\\n } else {\\n (src, None)\\n }\\n }\\n SourceMapsConfig::Str(_) => {\\n let mut src = src;\\n\\n let mut buf = vec![];\\n\\n self.cm\\n .build_source_map_with_config(\\n &mut src_map_buf,\\n orig,\\n SwcSourceMapConfig {\\n source_file_name,\\n output_path: output_path.as_deref(),\\n names: source_map_names,\\n inline_sources_content,\\n },\\n )\\n .to_writer(&mut buf)\\n .context(\"failed to write source map file\")?;\\n let map = String::from_utf8(buf).context(\"source map is not utf-8\")?;\\n\\n src.push_str(\"\\\\n//# sourceMappingURL=data:application/json;base64,\");\\n base64::encode_config_buf(\\n map.as_bytes(),\\n base64::Config::new(base64::CharacterSet::UrlSafe, true),\\n &mut src,\\n );\\n (src, None)\\n }\\n };\\n\\n Ok(TransformOutput { code, map })\\n })\\n }\\n}\\n\\nstruct SwcSourceMapConfig<\\'a> {\\n source_file_name: Option<&\\'a str>,\\n /// Output path of the `.map` file.\\n output_path: Option<&\\'a Path>,\\n\\n names: &\\'a [JsWord],\\n\\n inline_sources_content: bool,\\n}\\n\\nimpl SourceMapGenConfig for SwcSourceMapConfig<\\'_> {\\n fn file_name_to_source(&self, f: &FileName) -> String {\\n if let Some(file_name) = self.source_file_name {\\n return file_name.to_string();\\n }\\n\\n let base_path = match self.output_path {\\n Some(v) => v,\\n None => return f.to_string(),\\n };\\n let target = match f {\\n FileName::Real(v) => v,\\n _ => return f.to_string(),\\n };\\n\\n let rel = pathdiff::diff_paths(&target, base_path);\\n match rel {\\n Some(v) => {\\n let s = v.to_string_lossy().to_string();\\n if cfg!(target_os = \"windows\") {\\n s.replace(\"\\\\\\\\\", \"/\")\\n } else {\\n s\\n }\\n }\\n None => f.to_string(),\\n }\\n }\\n\\n fn names(&self) -> Vec<&str> {\\n self.names.iter().map(|v| &**v).collect()\\n }\\n\\n fn inline_sources_content(&self, _: &FileName) -> bool {\\n self.inline_sources_content\\n }\\n}\\n\\n/// High-level apis.\\nimpl Compiler {\\n pub fn new(cm: Arc) -> Self {\\n Compiler {\\n cm,\\n globals: Globals::new(),\\n comments: Default::default(),\\n }\\n }\\n\\n pub fn read_config(&self, opts: &Options, name: &FileName) -> Result, Error> {\\n static CUR_DIR: Lazy = Lazy::new(|| {\\n if cfg!(target_arch = \"wasm32\") {\\n PathBuf::new()\\n } else {\\n ::std::env::current_dir().unwrap()\\n }\\n });\\n\\n self.run(|| -> Result<_, Error> {\\n let Options {\\n ref root,\\n root_mode,\\n swcrc,\\n config_file,\\n ..\\n } = opts;\\n\\n let root = root.as_ref().unwrap_or_else(|| &CUR_DIR);\\n\\n let config_file = match config_file {\\n Some(ConfigFile::Str(ref s)) => Some(load_swcrc(Path::new(&s))?),\\n _ => None,\\n };\\n\\n match name {\\n FileName::Real(ref path) => {\\n if *swcrc {\\n let mut parent = path.parent();\\n while let Some(dir) = parent {\\n let swcrc = dir.join(\".swcrc\");\\n\\n if swcrc.exists() {\\n let config = load_swcrc(&swcrc)?;\\n\\n let mut config = config\\n .into_config(Some(path))\\n .context(\"failed to process config file\")?;\\n\\n if let Some(config_file) = config_file {\\n config.merge(&config_file.into_config(Some(path))?)\\n }\\n\\n if let Some(c) = &mut config {\\n if c.jsc.base_url != PathBuf::new() {\\n let joined = dir.join(&c.jsc.base_url);\\n c.jsc.base_url = if cfg!(target_os = \"windows\")\\n && c.jsc.base_url.as_os_str() == \".\"\\n {\\n dir.canonicalize().with_context(|| {\\n format!(\\n \"failed to canonicalize base url using the \\\\\\n path of .swcrc\\\\nDir: {}\\\\n(Used logic for \\\\\\n windows)\",\\n dir.display(),\\n )\\n })?\\n } else {\\n joined.canonicalize().with_context(|| {\\n format!(\\n \"failed to canonicalize base url using the \\\\\\n path of .swcrc\\\\nPath: {}\\\\nDir: {}\\\\nbaseUrl: \\\\\\n {}\",\\n joined.display(),\\n dir.display(),\\n c.jsc.base_url.display()\\n )\\n })?\\n };\\n }\\n }\\n\\n return Ok(config);\\n }\\n\\n if dir == root && *root_mode == RootMode::Root {\\n break;\\n }\\n parent = dir.parent();\\n }\\n }\\n\\n let config_file = config_file.unwrap_or_else(|| Rc::default());\\n let config = config_file.into_config(Some(path))?;\\n\\n return Ok(config);\\n }\\n _ => {}\\n }\\n\\n let config = match config_file {\\n Some(config_file) => config_file.into_config(None)?,\\n None => Rc::default().into_config(None)?,\\n };\\n\\n match config {\\n Some(config) => Ok(Some(config)),\\n None => {\\n bail!(\"no config matched for file ({})\", name)\\n }\\n }\\n })\\n .with_context(|| format!(\"failed to read swcrc file ({})\", name))\\n }\\n\\n /// This method returns [None] if a file should be skipped.\\n ///\\n /// This method handles merging of config.\\n ///\\n /// This method does **not** parse module.\\n pub fn config_for_file<\\'a>(\\n &\\'a self,\\n handler: &Handler,\\n opts: &Options,\\n name: &FileName,\\n before_pass: impl \\'a + swc_ecma_visit::Fold,\\n ) -> Result>, Error> {\\n self.run(|| -> Result<_, Error> {\\n let config = self.read_config(opts, name)?;\\n let config = match config {\\n Some(v) => v,\\n None => return Ok(None),\\n };\\n\\n let built = opts.build(\\n &self.cm,\\n name,\\n opts.output_path.as_deref(),\\n opts.source_file_name.clone(),\\n &handler,\\n opts.is_module,\\n Some(config),\\n Some(&self.comments),\\n before_pass,\\n );\\n Ok(Some(built))\\n })\\n .with_context(|| format!(\"failed to load config for file \\'{:?}\\'\", name))\\n }\\n\\n pub fn run_transform(&self, handler: &Handler, external_helpers: bool, op: F) -> Ret\\n where\\n F: FnOnce() -> Ret,\\n {\\n self.run(|| {\\n helpers::HELPERS.set(&Helpers::new(external_helpers), || {\\n swc_ecma_utils::HANDLER.set(handler, || op())\\n })\\n })\\n }\\n\\n pub fn transform(\\n &self,\\n handler: &Handler,\\n program: Program,\\n external_helpers: bool,\\n mut pass: impl swc_ecma_visit::Fold,\\n ) -> Program {\\n self.run_transform(handler, external_helpers, || {\\n // Fold module\\n program.fold_with(&mut pass)\\n })\\n }\\n\\n /// `custom_after_pass` is applied after swc transforms are applied.\\n pub fn process_js_with_custom_pass(\\n &self,\\n fm: Arc,\\n handler: &Handler,\\n opts: &Options,\\n custom_before_pass: P1,\\n custom_after_pass: P2,\\n ) -> Result\\n where\\n P1: swc_ecma_visit::Fold,\\n P2: swc_ecma_visit::Fold,\\n {\\n self.run(|| -> Result<_, Error> {\\n let config =\\n self.run(|| self.config_for_file(handler, opts, &fm.name, custom_before_pass))?;\\n let config = match config {\\n Some(v) => v,\\n None => {\\n bail!(\"cannot process file because it\\'s ignored by .swcrc\")\\n }\\n };\\n let config = BuiltConfig {\\n pass: chain!(config.pass, custom_after_pass),\\n syntax: config.syntax,\\n target: config.target,\\n minify: config.minify,\\n external_helpers: config.external_helpers,\\n source_maps: config.source_maps,\\n input_source_map: config.input_source_map,\\n is_module: config.is_module,\\n output_path: config.output_path,\\n source_file_name: config.source_file_name,\\n preserve_comments: config.preserve_comments,\\n inline_sources_content: config.inline_sources_content,\\n };\\n\\n let orig = if opts\\n .config\\n .source_maps\\n .as_ref()\\n .map(|v| v.enabled())\\n .unwrap_or_default()\\n {\\n self.get_orig_src_map(&fm, &opts.config.input_source_map, false)?\\n } else {\\n None\\n };\\n\\n let program = self.parse_js(\\n fm.clone(),\\n handler,\\n config.target,\\n config.syntax,\\n config.is_module,\\n true,\\n )?;\\n\\n self.process_js_inner(handler, program, orig.as_ref(), config)\\n })\\n .context(\"failed to process js file\")\\n }\\n\\n pub fn process_js_file(\\n &self,\\n fm: Arc,\\n handler: &Handler,\\n opts: &Options,\\n ) -> Result {\\n self.process_js_with_custom_pass(fm, handler, opts, noop(), noop())\\n }\\n\\n pub fn minify(\\n &self,\\n fm: Arc,\\n handler: &Handler,\\n opts: &JsMinifyOptions,\\n ) -> Result {\\n self.run(|| {\\n let target = opts.ecma.clone().into();\\n\\n let (source_map, orig) = match &opts.source_map {\\n BoolOrObject::Bool(false) => (SourceMapsConfig::Bool(false), None),\\n BoolOrObject::Bool(true) => (SourceMapsConfig::Bool(true), None),\\n BoolOrObject::Obj(obj) => {\\n let orig = obj\\n .content\\n .as_ref()\\n .map(|s| sourcemap::SourceMap::from_slice(s.as_bytes()));\\n let orig = match orig {\\n Some(v) => Some(v?),\\n None => None,\\n };\\n (SourceMapsConfig::Bool(true), orig)\\n }\\n };\\n\\n let min_opts = MinifyOptions {\\n compress: opts\\n .compress\\n .clone()\\n .into_obj()\\n .map(|v| v.into_config(self.cm.clone())),\\n mangle: opts.mangle.clone().into_obj(),\\n ..Default::default()\\n };\\n\\n let module = self\\n .parse_js(\\n fm.clone(),\\n handler,\\n target,\\n Syntax::Es(EsConfig {\\n jsx: true,\\n decorators: true,\\n decorators_before_export: true,\\n top_level_await: true,\\n import_assertions: true,\\n dynamic_import: true,\\n\\n ..Default::default()\\n }),\\n true,\\n true,\\n )\\n .context(\"failed to parse input file\")?\\n .expect_module();\\n\\n let source_map_names = {\\n let mut v = IdentCollector {\\n names: Default::default(),\\n };\\n\\n module.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n\\n v.names\\n };\\n\\n let top_level_mark = Mark::fresh(Mark::root());\\n\\n let module = self.run_transform(handler, false, || {\\n let module = module.fold_with(&mut resolver_with_mark(top_level_mark));\\n\\n let module = swc_ecma_minifier::optimize(\\n module,\\n self.cm.clone(),\\n Some(&self.comments),\\n None,\\n &min_opts,\\n &swc_ecma_minifier::option::ExtraOptions { top_level_mark },\\n );\\n\\n module\\n .fold_with(&mut hygiene())\\n .fold_with(&mut fixer(Some(&self.comments as &dyn Comments)))\\n });\\n\\n self.print(\\n &module,\\n Some(&fm.name.to_string()),\\n opts.output_path.clone().map(From::from),\\n opts.inline_sources_content,\\n target,\\n source_map,\\n &source_map_names,\\n orig.as_ref(),\\n true,\\n Some(opts.format.comments.clone()),\\n )\\n })\\n }\\n\\n /// You can use custom pass with this method.\\n ///\\n /// There exists a [PassBuilder] to help building custom passes.\\n pub fn process_js(\\n &self,\\n handler: &Handler,\\n program: Program,\\n opts: &Options,\\n ) -> Result {\\n self.run(|| -> Result<_, Error> {\\n let loc = self.cm.lookup_char_pos(program.span().lo());\\n let fm = loc.file;\\n\\n let orig = if opts\\n .config\\n .source_maps\\n .as_ref()\\n .map(|v| v.enabled())\\n .unwrap_or_default()\\n {\\n self.get_orig_src_map(&fm, &opts.config.input_source_map, false)?\\n } else {\\n None\\n };\\n\\n let config = self.run(|| self.config_for_file(handler, opts, &fm.name, noop()))?;\\n\\n let config = match config {\\n Some(v) => v,\\n None => {\\n bail!(\"cannot process file because it\\'s ignored by .swcrc\")\\n }\\n };\\n\\n self.process_js_inner(handler, program, orig.as_ref(), config)\\n })\\n .context(\"failed to process js module\")\\n }\\n\\n fn process_js_inner(\\n &self,\\n handler: &Handler,\\n program: Program,\\n orig: Option<&sourcemap::SourceMap>,\\n config: BuiltConfig,\\n ) -> Result {\\n self.run(|| {\\n let source_map_names = {\\n let mut v = IdentCollector {\\n names: Default::default(),\\n };\\n\\n program.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n\\n v.names\\n };\\n\\n let mut pass = config.pass;\\n let program = helpers::HELPERS.set(&Helpers::new(config.external_helpers), || {\\n swc_ecma_utils::HANDLER.set(handler, || {\\n // Fold module\\n program.fold_with(&mut pass)\\n })\\n });\\n\\n self.print(\\n &program,\\n config.source_file_name.as_deref(),\\n config.output_path,\\n config.inline_sources_content,\\n config.target,\\n config.source_maps,\\n &source_map_names,\\n orig,\\n config.minify,\\n config.preserve_comments,\\n )\\n })\\n }\\n}\\n\\nfn load_swcrc(path: &Path) -> Result {\\n fn convert_json_err(e: serde_json::Error) -> Error {\\n let line = e.line();\\n let column = e.column();\\n\\n let msg = match e.classify() {\\n Category::Io => \"io error\",\\n Category::Syntax => \"syntax error\",\\n Category::Data => \"unmatched data\",\\n Category::Eof => \"unexpected eof\",\\n };\\n Error::new(e).context(format!(\\n \"failed to deserialize .swcrc (json) file: {}: {}:{}\",\\n msg, line, column\\n ))\\n }\\n\\n let content = read_to_string(path).context(\"failed to read config (.swcrc) file\")?;\\n\\n match serde_json::from_str(&content) {\\n Ok(v) => return Ok(v),\\n Err(..) => {}\\n }\\n\\n serde_json::from_str::(&content)\\n .map(Rc::Single)\\n .map_err(convert_json_err)\\n}\\n\\ntype CommentMap = Arc, ahash::RandomState>>;\\n\\n/// Multi-threaded implementation of [Comments]\\n#[derive(Clone, Default)]\\npub struct SwcComments {\\n pub leading: CommentMap,\\n pub trailing: CommentMap,\\n}\\n\\nimpl Comments for SwcComments {\\n fn add_leading(&self, pos: BytePos, cmt: Comment) {\\n self.leading.entry(pos).or_default().push(cmt);\\n }\\n\\n fn add_leading_comments(&self, pos: BytePos, comments: Vec) {\\n self.leading.entry(pos).or_default().extend(comments);\\n }\\n\\n fn has_leading(&self, pos: BytePos) -> bool {\\n if let Some(v) = self.leading.get(&pos) {\\n !v.is_empty()\\n } else {\\n false\\n }\\n }\\n\\n fn move_leading(&self, from: BytePos, to: BytePos) {\\n let cmt = self.leading.remove(&from);\\n\\n if let Some(cmt) = cmt {\\n self.leading.entry(to).or_default().extend(cmt.1);\\n }\\n }\\n\\n fn take_leading(&self, pos: BytePos) -> Option> {\\n self.leading.remove(&pos).map(|v| v.1)\\n }\\n\\n fn get_leading(&self, pos: BytePos) -> Option> {\\n self.leading.get(&pos).map(|v| v.to_owned())\\n }\\n\\n fn add_trailing(&self, pos: BytePos, cmt: Comment) {\\n self.trailing.entry(pos).or_default().push(cmt)\\n }\\n\\n fn add_trailing_comments(&self, pos: BytePos, comments: Vec) {\\n self.trailing.entry(pos).or_default().extend(comments)\\n }\\n\\n fn has_trailing(&self, pos: BytePos) -> bool {\\n if let Some(v) = self.trailing.get(&pos) {\\n !v.is_empty()\\n } else {\\n false\\n }\\n }\\n\\n fn move_trailing(&self, from: BytePos, to: BytePos) {\\n let cmt = self.trailing.remove(&from);\\n\\n if let Some(cmt) = cmt {\\n self.trailing.entry(to).or_default().extend(cmt.1);\\n }\\n }\\n\\n fn take_trailing(&self, pos: BytePos) -> Option> {\\n self.trailing.remove(&pos).map(|v| v.1)\\n }\\n\\n fn get_trailing(&self, pos: BytePos) -> Option> {\\n self.trailing.get(&pos).map(|v| v.to_owned())\\n }\\n\\n fn add_pure_comment(&self, pos: BytePos) {\\n let mut leading = self.leading.entry(pos).or_default();\\n let pure_comment = Comment {\\n kind: CommentKind::Block,\\n span: DUMMY_SP,\\n text: \"#__PURE__\".into(),\\n };\\n\\n if !leading.iter().any(|c| c.text == pure_comment.text) {\\n leading.push(pure_comment);\\n }\\n }\\n}\\n\\npub struct IdentCollector {\\n names: Vec,\\n}\\n\\nimpl Visit for IdentCollector {\\n noop_visit_type!();\\n\\n fn visit_ident(&mut self, ident: &Ident, _: &dyn swc_ecma_visit::Node) {\\n if self.names.contains(&ident.sym) {\\n return;\\n }\\n\\n self.names.push(ident.sym.clone());\\n }\\n}\\n',\n", + " 'content_id': 'd2719c4b9154526c288ee61d6323945efb80540d',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 137,\n", + " 'path': '/src/lib.rs',\n", + " 'size': 40533,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.45738233397807865,\n", + " 'avg_line_length': 26.89568345323741,\n", + " 'blob_id': '46b93ab9321150ed3fa62492e43219418e1575d7',\n", + " 'content': 'use super::data::BUILTINS;\\nuse crate::{\\n corejs3::{\\n compat::DATA as CORE_JS_COMPAT_DATA,\\n data::{\\n COMMON_ITERATORS, INSTANCE_PROPERTIES, POSSIBLE_GLOBAL_OBJECTS, PROMISE_DEPENDENCIES,\\n STATIC_PROPERTIES,\\n },\\n },\\n util::DataMapExt,\\n version::should_enable,\\n Versions,\\n};\\nuse indexmap::IndexSet;\\nuse rustc_hash::FxHasher;\\nuse std::hash::BuildHasherDefault;\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::DUMMY_SP;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_visit::{noop_visit_type, Node, Visit, VisitWith};\\n\\npub(crate) struct UsageVisitor {\\n shipped_proposals: bool,\\n is_any_target: bool,\\n target: Versions,\\n pub required: IndexSet<&\\'static str, BuildHasherDefault>,\\n}\\n\\nimpl UsageVisitor {\\n pub fn new(target: Versions, shipped_proposals: bool) -> Self {\\n // let mut v = Self { required: vec![] };\\n //\\n //\\n // let is_web_target = target\\n // .iter()\\n // .any(|(name, version)| name != \"node\" &&\\n // version.is_some());\\n //\\n // println!(\\n // \"is_any_target={:?}\\\\nis_web_target={:?}\",\\n // is_any_target, is_web_target\\n // );\\n //\\n // // Web default\\n // if is_any_target || is_web_target {\\n // v.add(&[\"web.timers\", \"web.immediate\",\\n // \"web.dom.iterable\"]); }\\n // v\\n\\n Self {\\n shipped_proposals,\\n is_any_target: target.is_any_target(),\\n target,\\n required: Default::default(),\\n }\\n }\\n\\n /// Add imports\\n fn add(&mut self, features: &[&\\'static str]) {\\n let UsageVisitor {\\n shipped_proposals,\\n is_any_target,\\n target,\\n ..\\n } = self;\\n\\n self.required.extend(features.iter().filter_map(|f| {\\n if !*shipped_proposals && f.starts_with(\"esnext.\") {\\n return None;\\n }\\n\\n let feature = CORE_JS_COMPAT_DATA.get(&**f);\\n\\n if !*is_any_target {\\n if let Some(feature) = feature {\\n if !should_enable(*target, *feature, true) {\\n return None;\\n }\\n }\\n }\\n\\n Some(f)\\n }));\\n }\\n\\n fn add_builtin(&mut self, built_in: &str) {\\n if let Some(features) = BUILTINS.get_data(built_in) {\\n self.add(features)\\n }\\n }\\n fn add_property_deps(&mut self, obj: &Expr, prop: &Expr) {\\n let prop = match prop {\\n Expr::Ident(i) => &i.sym,\\n Expr::Lit(Lit::Str(s)) => &s.value,\\n _ => return,\\n };\\n\\n let obj = match obj {\\n Expr::Ident(i) => &i.sym,\\n _ => {\\n self.add_property_deps_inner(None, prop);\\n return;\\n }\\n };\\n\\n self.add_property_deps_inner(Some(obj), prop)\\n }\\n\\n fn add_property_deps_inner(&mut self, obj: Option<&JsWord>, prop: &JsWord) {\\n if let Some(obj) = obj {\\n if POSSIBLE_GLOBAL_OBJECTS.contains(&&**obj) {\\n self.add_builtin(prop);\\n }\\n\\n if let Some(map) = STATIC_PROPERTIES.get_data(&obj) {\\n if let Some(features) = map.get_data(&prop) {\\n self.add(features);\\n }\\n }\\n }\\n\\n if let Some(features) = INSTANCE_PROPERTIES.get_data(&prop) {\\n self.add(features);\\n }\\n }\\n\\n fn visit_object_pat_props(&mut self, obj: &Expr, props: &[ObjectPatProp]) {\\n let obj = match obj {\\n Expr::Ident(i) => Some(&i.sym),\\n _ => None,\\n };\\n\\n for p in props {\\n match p {\\n ObjectPatProp::KeyValue(KeyValuePatProp {\\n key: PropName::Ident(i),\\n ..\\n }) => self.add_property_deps_inner(obj, &i.sym),\\n ObjectPatProp::Assign(AssignPatProp { key, .. }) => {\\n self.add_property_deps_inner(obj, &key.sym)\\n }\\n\\n _ => {}\\n }\\n }\\n }\\n}\\n\\nimpl Visit for UsageVisitor {\\n noop_visit_type!();\\n\\n /// `[a, b] = c`\\n fn visit_array_pat(&mut self, p: &ArrayPat, _: &dyn Node) {\\n p.visit_children_with(self);\\n\\n self.add(COMMON_ITERATORS)\\n }\\n\\n fn visit_assign_expr(&mut self, e: &AssignExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match &e.left {\\n // ({ keys, values } = Object)\\n PatOrExpr::Pat(pat) => match &**pat {\\n Pat::Object(ref o) => self.visit_object_pat_props(&e.right, &o.props),\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n fn visit_bin_expr(&mut self, e: &BinExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match e.op {\\n op!(\"in\") => {\\n // \\'entries\\' in Object\\n // \\'entries\\' in [1, 2, 3]\\n self.add_property_deps(&e.right, &e.left);\\n }\\n _ => {}\\n }\\n }\\n\\n /// import(\\'something\\').then(...)\\n fn visit_call_expr(&mut self, e: &CallExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n if let ExprOrSuper::Expr(expr) = &e.callee {\\n match &**expr {\\n Expr::Ident(Ident {\\n sym: js_word!(\"import\"),\\n ..\\n }) => self.add(PROMISE_DEPENDENCIES),\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_expr(&mut self, e: &Expr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match e {\\n Expr::Ident(i) => self.add_builtin(&i.sym),\\n _ => {}\\n }\\n }\\n\\n /// `[...spread]`\\n fn visit_expr_or_spread(&mut self, e: &ExprOrSpread, _: &dyn Node) {\\n e.visit_children_with(self);\\n if e.spread.is_some() {\\n self.add(COMMON_ITERATORS)\\n }\\n }\\n\\n /// for-of\\n fn visit_for_of_stmt(&mut self, s: &ForOfStmt, _: &dyn Node) {\\n s.visit_children_with(self);\\n\\n self.add(COMMON_ITERATORS)\\n }\\n\\n fn visit_function(&mut self, f: &Function, _: &dyn Node) {\\n f.visit_children_with(self);\\n\\n if f.is_async {\\n self.add(PROMISE_DEPENDENCIES)\\n }\\n }\\n\\n fn visit_member_expr(&mut self, e: &MemberExpr, _: &dyn Node) {\\n e.obj.visit_with(e as _, self);\\n if e.computed {\\n e.prop.visit_with(e as _, self);\\n }\\n\\n // Object.entries\\n // [1, 2, 3].entries\\n\\n match e.obj {\\n ExprOrSuper::Expr(ref obj) => self.add_property_deps(&obj, &e.prop),\\n _ => {}\\n }\\n }\\n\\n fn visit_var_declarator(&mut self, d: &VarDeclarator, _: &dyn Node) {\\n d.visit_children_with(self);\\n\\n if let Some(ref init) = d.init {\\n match d.name {\\n // const { keys, values } = Object\\n Pat::Object(ref o) => self.visit_object_pat_props(&init, &o.props),\\n _ => {}\\n }\\n } else {\\n match d.name {\\n // const { keys, values } = Object\\n Pat::Object(ref o) => self.visit_object_pat_props(\\n &Expr::Ident(Ident::new(js_word!(\"\"), DUMMY_SP)),\\n &o.props,\\n ),\\n _ => {}\\n }\\n }\\n }\\n\\n // TODO: https://github.com/babel/babel/blob/00758308/packages/babel-preset-env/src/polyfills/corejs3/usage-plugin.js#L198-L206\\n\\n /// `yield*`\\n fn visit_yield_expr(&mut self, e: &YieldExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n if e.delegate {\\n self.add(COMMON_ITERATORS)\\n }\\n }\\n}\\n',\n", + " 'content_id': 'c50379b7157612523e509b0e8ca1a6d6b5490628',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 131,\n", + " 'path': '/ecmascript/preset-env/src/corejs3/usage.rs',\n", + " 'size': 7755,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6114093959731544,\n", + " 'avg_line_length': 41.57142857142857,\n", + " 'blob_id': '98bd53090ea769995aacdcb19ac4954e55937aed',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_react/\"\\nedition = \"2018\"\\ninclude = [\"Cargo.toml\", \"src/**/*.rs\"]\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_react\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.46.1\"\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nbase64 = \"0.13.0\"\\ndashmap = \"4.0.2\"\\nindexmap = \"1.6.1\"\\nonce_cell = \"1.5.2\"\\nregex = \"1.4.2\"\\nserde = {version = \"1.0.118\", features = [\"derive\"]}\\nsha-1 = \"0.9.4\"\\nstring_enum = {version = \"0.3.1\", path = \"../../../macros/string_enum\"}\\nswc_atoms = {version = \"0.2\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\n\\n[dev-dependencies]\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../../codegen/\"}\\nswc_ecma_transforms_compat = {version = \"0.40.0\", path = \"../compat/\"}\\nswc_ecma_transforms_module = {version = \"0.44.0\", path = \"../module\"}\\nswc_ecma_transforms_testing = {version = \"0.36.0\", path = \"../testing/\"}\\ntesting = {version = \"0.14.0\", path = \"../../../testing\"}\\n',\n", + " 'content_id': '5698f699f11dd1d331684e770347565c15ba6e23',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/transforms/react/Cargo.toml',\n", + " 'size': 1490,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.34189575817887796,\n", + " 'avg_line_length': 37.28095238095238,\n", + " 'blob_id': 'fd36dfffeca72628d73b90aabd9f27c1869cbd05',\n", + " 'content': 'use crate::{hash::calc_hash, Bundle, BundleKind, Bundler, Load, ModuleType, Resolve};\\nuse ahash::AHashMap;\\nuse anyhow::Error;\\nuse relative_path::RelativePath;\\nuse std::path::{Path, PathBuf};\\nuse swc_atoms::js_word;\\nuse swc_common::{util::move_map::MoveMap, FileName, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms::{\\n fixer,\\n helpers::{inject_helpers, HELPERS},\\n hygiene,\\n};\\nuse swc_ecma_utils::{find_ids, private_ident, ExprFactory};\\nuse swc_ecma_visit::{noop_fold_type, noop_visit_type, Fold, FoldWith, Node, Visit, VisitWith};\\n\\nimpl Bundler<\\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// This method do\\n ///\\n /// - inject helpers\\n /// - rename chunks\\n /// - invoke fixer\\n pub(super) fn finalize(&self, bundles: Vec) -> Result, Error> {\\n self.run(|| {\\n let mut new = Vec::with_capacity(bundles.len());\\n let mut renamed = AHashMap::default();\\n\\n for mut bundle in bundles {\\n bundle.module = self.optimize(bundle.module);\\n\\n bundle.module = bundle.module.fold_with(&mut hygiene());\\n\\n bundle.module = self.may_wrap_with_iife(bundle.module);\\n\\n bundle.module = bundle.module.fold_with(&mut fixer(None));\\n\\n {\\n // Inject swc helpers\\n let swc_helpers = self\\n .scope\\n .get_module(bundle.id)\\n .expect(\"module should exist at this point\")\\n .swc_helpers;\\n\\n let module = bundle.module;\\n\\n bundle.module =\\n HELPERS.set(&swc_helpers, || module.fold_with(&mut inject_helpers()));\\n }\\n\\n match bundle.kind {\\n BundleKind::Named { .. } => {\\n // Inject helpers\\n let helpers = self\\n .scope\\n .get_module(bundle.id)\\n .expect(\"module should exist at this point\")\\n .helpers;\\n\\n helpers.add_to(&mut bundle.module.body);\\n\\n new.push(Bundle { ..bundle });\\n }\\n BundleKind::Lib { name } => {\\n let hash = calc_hash(self.cm.clone(), &bundle.module)?;\\n let mut new_name = PathBuf::from(name);\\n let key = new_name.clone();\\n let file_name = new_name\\n .file_name()\\n .map(|path| -> PathBuf {\\n let path = Path::new(path);\\n let ext = path.extension();\\n if let Some(ext) = ext {\\n return format!(\\n \"{}-{}.{}\",\\n path.file_stem().unwrap().to_string_lossy(),\\n hash,\\n ext.to_string_lossy()\\n )\\n .into();\\n }\\n return format!(\\n \"{}-{}\",\\n path.file_stem().unwrap().to_string_lossy(),\\n hash,\\n )\\n .into();\\n })\\n .expect(\"javascript file should have name\");\\n new_name.pop();\\n new_name = new_name.join(file_name.clone());\\n\\n renamed.insert(key, new_name.to_string_lossy().to_string());\\n\\n new.push(Bundle {\\n kind: BundleKind::Named {\\n name: file_name.display().to_string(),\\n },\\n ..bundle\\n })\\n }\\n _ => new.push(bundle),\\n }\\n }\\n\\n if new.len() == 1 {\\n return Ok(new);\\n }\\n\\n new = new.move_map(|bundle| {\\n let path = match self.scope.get_module(bundle.id).unwrap().fm.name {\\n FileName::Real(ref v) => v.clone(),\\n _ => {\\n tracing::error!(\"Cannot rename: not a real file\");\\n return bundle;\\n }\\n };\\n\\n let module = {\\n // Change imports\\n let mut v = Renamer {\\n resolver: &self.resolver,\\n base: &path,\\n renamed: &renamed,\\n };\\n bundle.module.fold_with(&mut v)\\n };\\n\\n Bundle { module, ..bundle }\\n });\\n\\n Ok(new)\\n })\\n }\\n\\n fn may_wrap_with_iife(&self, module: Module) -> Module {\\n if self.config.module != ModuleType::Iife {\\n return module;\\n }\\n\\n let mut top_level_await_finder = TopLevelAwaitFinder::default();\\n module.visit_with(&Invalid { span: DUMMY_SP }, &mut top_level_await_finder);\\n\\n let is_async = top_level_await_finder.found;\\n\\n // Properties of returned object\\n let mut props = vec![];\\n\\n let mut body = BlockStmt {\\n span: module.span,\\n stmts: module\\n .body\\n .into_iter()\\n .filter_map(|item| {\\n let decl = match item {\\n ModuleItem::ModuleDecl(v) => v,\\n ModuleItem::Stmt(stmt) => return Some(stmt),\\n };\\n\\n match decl {\\n ModuleDecl::ExportNamed(NamedExport { src: Some(..), .. })\\n | ModuleDecl::TsImportEquals(_)\\n | ModuleDecl::TsExportAssignment(_)\\n | ModuleDecl::TsNamespaceExport(_)\\n | ModuleDecl::Import(_) => None,\\n\\n ModuleDecl::ExportDecl(export) => {\\n match &export.decl {\\n Decl::Class(ClassDecl { ident, .. })\\n | Decl::Fn(FnDecl { ident, .. }) => {\\n props.push(PropOrSpread::Prop(Box::new(Prop::Shorthand(\\n ident.clone(),\\n ))));\\n }\\n Decl::Var(decl) => {\\n let ids: Vec = find_ids(decl);\\n props.extend(\\n ids.into_iter()\\n .map(Prop::Shorthand)\\n .map(Box::new)\\n .map(PropOrSpread::Prop),\\n );\\n }\\n _ => unreachable!(),\\n }\\n\\n Some(Stmt::Decl(export.decl))\\n }\\n\\n ModuleDecl::ExportNamed(NamedExport {\\n specifiers,\\n src: None,\\n ..\\n }) => {\\n for s in specifiers {\\n match s {\\n ExportSpecifier::Namespace(..) => {\\n // unreachable\\n }\\n ExportSpecifier::Default(s) => {\\n props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(\\n js_word!(\"default\"),\\n DUMMY_SP,\\n )),\\n value: Box::new(Expr::Ident(s.exported)),\\n },\\n ))));\\n }\\n ExportSpecifier::Named(s) => match s.exported {\\n Some(exported) => {\\n props.push(PropOrSpread::Prop(Box::new(\\n Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(exported),\\n value: Box::new(Expr::Ident(s.orig)),\\n }),\\n )));\\n }\\n None => {\\n props.push(PropOrSpread::Prop(Box::new(\\n Prop::Shorthand(s.orig),\\n )));\\n }\\n },\\n }\\n }\\n\\n None\\n }\\n\\n ModuleDecl::ExportDefaultDecl(export) => match export.decl {\\n DefaultDecl::Class(expr) => {\\n let ident = expr.ident;\\n let ident =\\n ident.unwrap_or_else(|| private_ident!(\"_default_decl\"));\\n\\n props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(\\n js_word!(\"default\"),\\n export.span,\\n )),\\n value: Box::new(Expr::Ident(ident.clone())),\\n },\\n ))));\\n\\n Some(Stmt::Decl(Decl::Class(ClassDecl {\\n ident,\\n class: expr.class,\\n declare: false,\\n })))\\n }\\n DefaultDecl::Fn(expr) => {\\n let ident = expr.ident;\\n let ident =\\n ident.unwrap_or_else(|| private_ident!(\"_default_decl\"));\\n\\n props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(\\n js_word!(\"default\"),\\n export.span,\\n )),\\n value: Box::new(Expr::Ident(ident.clone())),\\n },\\n ))));\\n\\n Some(Stmt::Decl(Decl::Fn(FnDecl {\\n ident,\\n function: expr.function,\\n declare: false,\\n })))\\n }\\n DefaultDecl::TsInterfaceDecl(_) => None,\\n },\\n ModuleDecl::ExportDefaultExpr(export) => {\\n let default_var = private_ident!(\"default\");\\n props.push(PropOrSpread::Prop(Box::new(Prop::Shorthand(\\n default_var.clone(),\\n ))));\\n let var = VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(default_var.into()),\\n init: Some(export.expr),\\n definite: false,\\n };\\n Some(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Const,\\n declare: false,\\n decls: vec![var],\\n })))\\n }\\n\\n ModuleDecl::ExportAll(_) => None,\\n }\\n })\\n .collect(),\\n };\\n body.stmts.push(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props,\\n }))),\\n }));\\n\\n let f = Function {\\n is_generator: false,\\n is_async,\\n params: Default::default(),\\n decorators: Default::default(),\\n span: DUMMY_SP,\\n body: Some(body),\\n type_params: Default::default(),\\n return_type: Default::default(),\\n };\\n\\n let invoked_fn_expr = FnExpr {\\n ident: None,\\n function: f,\\n };\\n\\n let iife = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: invoked_fn_expr.as_callee(),\\n args: Default::default(),\\n type_args: Default::default(),\\n }));\\n\\n Module {\\n span: DUMMY_SP,\\n shebang: None,\\n body: vec![ModuleItem::Stmt(Stmt::Expr(ExprStmt {\\n span: DUMMY_SP,\\n expr: iife,\\n }))],\\n }\\n }\\n}\\n\\n#[derive(Default)]\\nstruct TopLevelAwaitFinder {\\n found: bool,\\n}\\n\\nimpl Visit for TopLevelAwaitFinder {\\n noop_visit_type!();\\n\\n fn visit_stmts(&mut self, _: &[Stmt], _: &dyn Node) {}\\n\\n fn visit_await_expr(&mut self, _: &AwaitExpr, _: &dyn Node) {\\n self.found = true;\\n }\\n}\\n\\n/// Import renamer. This pass changes import path.\\nstruct Renamer<\\'a, R>\\nwhere\\n R: Resolve,\\n{\\n resolver: R,\\n base: &\\'a PathBuf,\\n renamed: &\\'a AHashMap,\\n}\\n\\nimpl Fold for Renamer<\\'_, R>\\nwhere\\n R: Resolve,\\n{\\n noop_fold_type!();\\n\\n fn fold_import_decl(&mut self, import: ImportDecl) -> ImportDecl {\\n let resolved = match self\\n .resolver\\n .resolve(&FileName::Real(self.base.clone()), &import.src.value)\\n {\\n Ok(v) => match v {\\n FileName::Real(v) => v,\\n _ => panic!(\"rename_bundles called with non-path module\"),\\n },\\n Err(_) => return import,\\n };\\n\\n if let Some(v) = self.renamed.get(&resolved) {\\n // We use parent because RelativePath uses ../common-[hash].js\\n // if we use `entry-a.js` as a base.\\n //\\n // entry-a.js\\n // common.js\\n let base = self\\n .base\\n .parent()\\n .unwrap_or(self.base)\\n .as_os_str()\\n .to_string_lossy();\\n let base = RelativePath::new(&*base);\\n let v = base.relative(&*v);\\n let value = v.as_str();\\n return ImportDecl {\\n src: Str {\\n value: if value.starts_with(\".\") {\\n value.into()\\n } else {\\n format!(\"./{}\", value).into()\\n },\\n ..import.src\\n },\\n ..import\\n };\\n }\\n\\n import\\n }\\n}\\n',\n", + " 'content_id': '58abf7f81572c7c93881b40cfa3c9f8bdb831a47',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 94,\n", + " 'path': '/bundler/src/bundler/finalize.rs',\n", + " 'size': 16078,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6097875080489376,\n", + " 'avg_line_length': 33.51111111111111,\n", + " 'blob_id': '82743b02818cf59c144409435a343dcddeb80fda',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"EcmaScript code minifier.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_minifier/\"\\nedition = \"2018\"\\ninclude = [\"Cargo.toml\", \"src/**/*.rs\", \"src/lists/*.json\"]\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_minifier\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.36.0\"\\n\\n[features]\\ndebug = [\"backtrace\"]\\n\\n[dependencies]\\nbacktrace = {version = \"0.3.61\", optional = true}\\nindexmap = \"1.7.0\"\\nonce_cell = \"1.5.2\"\\npretty_assertions = {version = \"0.6.1\", optional = true}\\nrayon = \"1.5.1\"\\nregex = \"1.5.3\"\\nretain_mut = \"0.1.2\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1.0.118\", features = [\"derive\"]}\\nserde_json = \"1.0.61\"\\nserde_regex = \"1.1.0\"\\nswc_atoms = {version = \"0.2\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../codegen\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../parser\"}\\nswc_ecma_transforms = {version = \"0.80.0\", path = \"../transforms/\", features = [\"optimization\"]}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../transforms/base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../visit\"}\\ntracing = \"0.1.28\"\\nunicode-xid = \"0.2.2\"\\n\\n[dev-dependencies]\\nansi_term = \"0.12.1\"\\nanyhow = \"1\"\\npretty_assertions = \"0.6.1\"\\nswc_node_base = {version = \"0.4.0\", path = \"../../node/base\"}\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\nwalkdir = \"2.3.1\"\\n',\n", + " 'content_id': '33b31f6a0803fc5059321c5259058fb793e5a4f7',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/minifier/Cargo.toml',\n", + " 'size': 1553,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5865665415102211,\n", + " 'avg_line_length': 25.633333333333333,\n", + " 'blob_id': '4c320bdd791811afea3743fb4f6d030731f92d1d',\n", + " 'content': 'use crate::{\\n complete_output, get_compiler,\\n util::{CtxtExt, MapErr},\\n};\\nuse napi::{CallContext, JsObject, Task};\\nuse rustc_hash::FxHashMap;\\nuse serde::Deserialize;\\nuse std::sync::Arc;\\nuse swc::{try_with_handler, TransformOutput};\\nuse swc_common::{sync::Lrc, FileName, SourceFile, SourceMap};\\n\\nstruct MinifyTask {\\n c: Arc,\\n code: MinifyTarget,\\n opts: swc::config::JsMinifyOptions,\\n}\\n\\n#[derive(Deserialize)]\\n#[serde(untagged)]\\nenum MinifyTarget {\\n /// Code to minify.\\n Single(String),\\n /// `{ filename: code }`\\n Map(FxHashMap),\\n}\\n\\nimpl MinifyTarget {\\n fn to_file(&self, cm: Lrc) -> Lrc {\\n match self {\\n MinifyTarget::Single(code) => cm.new_source_file(FileName::Anon, code.clone()),\\n MinifyTarget::Map(codes) => {\\n assert_eq!(\\n codes.len(),\\n 1,\\n \"swc.minify does not support concatting multiple files yet\"\\n );\\n\\n let (filename, code) = codes.iter().next().unwrap();\\n\\n cm.new_source_file(FileName::Real(filename.clone().into()), code.clone())\\n }\\n }\\n }\\n}\\n\\nimpl Task for MinifyTask {\\n type Output = TransformOutput;\\n\\n type JsValue = JsObject;\\n\\n fn compute(&mut self) -> napi::Result {\\n try_with_handler(self.c.cm.clone(), |handler| {\\n let fm = self.code.to_file(self.c.cm.clone());\\n\\n self.c.minify(fm, &handler, &self.opts)\\n })\\n .convert_err()\\n }\\n\\n fn resolve(self, env: napi::Env, output: Self::Output) -> napi::Result {\\n complete_output(&env, output)\\n }\\n}\\n\\n#[js_function(2)]\\npub fn minify(cx: CallContext) -> napi::Result {\\n let code = cx.get_deserialized(0)?;\\n let opts = cx.get_deserialized(1)?;\\n\\n let c = get_compiler(&cx);\\n\\n let task = MinifyTask { c, code, opts };\\n\\n cx.env.spawn(task).map(|t| t.promise_object())\\n}\\n\\n#[js_function(2)]\\npub fn minify_sync(cx: CallContext) -> napi::Result {\\n let code: MinifyTarget = cx.get_deserialized(0)?;\\n let opts = cx.get_deserialized(1)?;\\n\\n let c = get_compiler(&cx);\\n\\n let fm = code.to_file(c.cm.clone());\\n\\n let output =\\n try_with_handler(c.cm.clone(), |handler| c.minify(fm, &handler, &opts)).convert_err()?;\\n\\n complete_output(&cx.env, output)\\n}\\n',\n", + " 'content_id': '6d28609a69117bad4202149a678f7525abca7ecd',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 95,\n", + " 'path': '/node/binding/src/minify.rs',\n", + " 'size': 2397,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.435106656386533,\n", + " 'avg_line_length': 31.628930817610062,\n", + " 'blob_id': 'f3471bd0a9a322514ef7d85ff4317b989263146e',\n", + " 'content': '#![allow(dead_code)]\\n\\nuse super::{export::Exports, helpers::Helpers, Bundler};\\nuse crate::{\\n bundler::{export::RawExports, import::RawImports},\\n id::{Id, ModuleId},\\n load::ModuleData,\\n util,\\n util::IntoParallelIterator,\\n Load, Resolve,\\n};\\nuse anyhow::{Context, Error};\\nuse is_macro::Is;\\n#[cfg(feature = \"rayon\")]\\nuse rayon::iter::ParallelIterator;\\nuse swc_atoms::js_word;\\nuse swc_common::{sync::Lrc, FileName, SourceFile, SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::{\\n CallExpr, Expr, ExprOrSuper, Ident, ImportDecl, ImportSpecifier, Invalid, MemberExpr, Module,\\n ModuleDecl, Str,\\n};\\nuse swc_ecma_transforms::resolver_with_mark;\\nuse swc_ecma_visit::{noop_visit_type, FoldWith, Node, Visit, VisitWith};\\n/// Module after applying transformations.\\n#[derive(Debug, Clone)]\\npub(crate) struct TransformedModule {\\n pub id: ModuleId,\\n pub fm: Lrc,\\n pub module: Lrc,\\n pub imports: Lrc,\\n pub exports: Lrc,\\n\\n /// If false, the module will be wrapped with a small helper function.\\n pub is_es6: bool,\\n\\n /// Used helpers\\n pub helpers: Lrc,\\n\\n pub swc_helpers: Lrc,\\n\\n local_ctxt: SyntaxContext,\\n export_ctxt: SyntaxContext,\\n}\\n\\nimpl TransformedModule {\\n /// [SyntaxContext] for exported items.\\n pub fn export_ctxt(&self) -> SyntaxContext {\\n self.export_ctxt\\n }\\n\\n /// Top level contexts.\\n pub fn local_ctxt(&self) -> SyntaxContext {\\n self.local_ctxt\\n }\\n}\\n\\nimpl Bundler<\\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// Phase 1 (discovery)\\n ///\\n /// We apply transforms at this phase to make cache efficient.\\n /// As we cache in this phase, changing dependency does not affect cache.\\n pub(super) fn load_transformed(\\n &self,\\n file_name: &FileName,\\n ) -> Result, Error> {\\n self.run(|| {\\n tracing::trace!(\"load_transformed: ({})\", file_name);\\n\\n // In case of common module\\n if let Some(cached) = self.scope.get_module_by_path(&file_name) {\\n tracing::debug!(\"Cached: {}\", file_name);\\n return Ok(Some(cached));\\n }\\n\\n let (_, data) = self.load(&file_name).context(\"Bundler.load() failed\")?;\\n let (v, mut files) = self\\n .analyze(&file_name, data)\\n .context(\"failed to analyze module\")?;\\n files.dedup_by_key(|v| v.1.clone());\\n\\n tracing::debug!(\\n \"({:?}, {:?}, {:?}) Storing module: {}\",\\n v.id,\\n v.local_ctxt(),\\n v.export_ctxt(),\\n file_name\\n );\\n self.scope.store_module(v.clone());\\n\\n // Load dependencies and store them in the `Scope`\\n let results = files\\n .into_par_iter()\\n .map(|(_src, path)| {\\n tracing::trace!(\"loading dependency: {}\", path);\\n self.load_transformed(&path)\\n })\\n .collect::>();\\n\\n // Do tasks in parallel, and then wait for result\\n for result in results {\\n result?;\\n }\\n\\n Ok(Some(v))\\n })\\n }\\n\\n fn load(&self, file_name: &FileName) -> Result<(ModuleId, ModuleData), Error> {\\n self.run(|| {\\n let (module_id, _, _) = self.scope.module_id_gen.gen(file_name);\\n\\n let data = self\\n .loader\\n .load(&file_name)\\n .with_context(|| format!(\"Bundler.loader.load({}) failed\", file_name))?;\\n self.scope.mark_as_loaded(module_id);\\n Ok((module_id, data))\\n })\\n }\\n\\n /// This methods returns [Source]s which should be loaded.\\n fn analyze(\\n &self,\\n file_name: &FileName,\\n data: ModuleData,\\n ) -> Result<(TransformedModule, Vec<(Source, Lrc)>), Error> {\\n self.run(|| {\\n tracing::trace!(\"transform_module({})\", data.fm.name);\\n let (id, local_mark, export_mark) = self.scope.module_id_gen.gen(file_name);\\n\\n let mut module = data.module.fold_with(&mut resolver_with_mark(local_mark));\\n\\n // {\\n // let code = self\\n // .swc\\n // .print(\\n // &module.clone().fold_with(&mut HygieneVisualizer),\\n // SourceMapsConfig::Bool(false),\\n // None,\\n // false,\\n // )\\n // .unwrap()\\n // .code;\\n //\\n // println!(\"Resolved:\\\\n{}\\\\n\\\\n\", code);\\n // }\\n\\n let imports = self.extract_import_info(file_name, &mut module, local_mark);\\n\\n // {\\n // let code = self\\n // .swc\\n // .print(\\n // &module.clone().fold_with(&mut HygieneVisualizer),\\n // SourceMapsConfig::Bool(false),\\n // None,\\n // false,\\n // )\\n // .unwrap()\\n // .code;\\n //\\n // println!(\"After imports:\\\\n{}\\\\n\", code,);\\n // }\\n\\n let exports = self.extract_export_info(\\n file_name,\\n &mut module,\\n SyntaxContext::empty().apply_mark(export_mark),\\n );\\n\\n let is_es6 = if !self.config.require {\\n true\\n } else {\\n let mut v = Es6ModuleDetector {\\n forced_es6: false,\\n found_other: false,\\n };\\n module.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n v.forced_es6 || !v.found_other\\n };\\n\\n let (imports, exports) = util::join(\\n || self.resolve_imports(file_name, imports),\\n || self.resolve_exports(file_name, exports),\\n );\\n let (imports, mut import_files) = imports?;\\n let (exports, reexport_files) = exports?;\\n import_files.extend(reexport_files);\\n\\n let module = Lrc::new(module);\\n\\n Ok((\\n TransformedModule {\\n id,\\n fm: data.fm,\\n module,\\n imports: Lrc::new(imports),\\n exports: Lrc::new(exports),\\n is_es6,\\n helpers: Default::default(),\\n swc_helpers: Lrc::new(data.helpers),\\n local_ctxt: SyntaxContext::empty().apply_mark(local_mark),\\n export_ctxt: SyntaxContext::empty().apply_mark(export_mark),\\n },\\n import_files,\\n ))\\n })\\n }\\n\\n /// Resolve re-exports.\\n fn resolve_exports(\\n &self,\\n base: &FileName,\\n raw: RawExports,\\n ) -> Result<(Exports, Vec<(Source, Lrc)>), Error> {\\n self.run(|| {\\n tracing::trace!(\"resolve_exports({})\", base);\\n let mut files = vec![];\\n\\n let mut exports = Exports::default();\\n\\n let items = raw\\n .items\\n .into_par_iter()\\n .map(|(src, ss)| -> Result<_, Error> {\\n self.run(|| {\\n let info = match src {\\n Some(src) => {\\n let name = self.resolve(base, &src.value)?;\\n let (id, local_mark, export_mark) =\\n self.scope.module_id_gen.gen(&name);\\n Some((id, local_mark, export_mark, name, src))\\n }\\n None => None,\\n };\\n\\n Ok((info, ss))\\n })\\n })\\n .collect::>();\\n\\n for res in items {\\n let (info, specifiers) = res?;\\n\\n match info {\\n None => exports.items.extend(specifiers),\\n Some((id, local_mark, export_mark, name, src)) => {\\n //\\n let src = Source {\\n is_loaded_synchronously: true,\\n is_unconditional: false,\\n module_id: id,\\n local_ctxt: SyntaxContext::empty().apply_mark(local_mark),\\n export_ctxt: SyntaxContext::empty().apply_mark(export_mark),\\n src,\\n };\\n exports.reexports.push((src.clone(), specifiers));\\n files.push((src, name));\\n }\\n }\\n }\\n\\n Ok((exports, files))\\n })\\n }\\n\\n /// Resolve dependencies\\n fn resolve_imports(\\n &self,\\n base: &FileName,\\n info: RawImports,\\n ) -> Result<(Imports, Vec<(Source, Lrc)>), Error> {\\n self.run(|| {\\n tracing::trace!(\"resolve_imports({})\", base);\\n let mut files = vec![];\\n\\n let mut merged = Imports::default();\\n let RawImports {\\n imports,\\n lazy_imports,\\n dynamic_imports,\\n forced_ns,\\n } = info;\\n\\n let loaded = imports\\n .into_par_iter()\\n .map(|v| (v, false, true))\\n .chain(lazy_imports.into_par_iter().map(|v| (v, false, false)))\\n .chain(dynamic_imports.into_par_iter().map(|src| {\\n (\\n ImportDecl {\\n span: src.span,\\n specifiers: vec![],\\n src,\\n type_only: false,\\n asserts: None,\\n },\\n true,\\n false,\\n )\\n }))\\n .map(|(decl, dynamic, unconditional)| -> Result<_, Error> {\\n self.run(|| {\\n //\\n let file_name = self.resolve(base, &decl.src.value)?;\\n let (id, local_mark, export_mark) =\\n self.scope.module_id_gen.gen(&file_name);\\n\\n Ok((\\n id,\\n local_mark,\\n export_mark,\\n file_name,\\n decl,\\n dynamic,\\n unconditional,\\n ))\\n })\\n })\\n .collect::>();\\n\\n for res in loaded {\\n // TODO: Report error and proceed instead of returning an error\\n let (id, local_mark, export_mark, file_name, decl, is_dynamic, is_unconditional) =\\n res?;\\n\\n let src = Source {\\n is_loaded_synchronously: !is_dynamic,\\n is_unconditional,\\n module_id: id,\\n local_ctxt: SyntaxContext::empty().apply_mark(local_mark),\\n export_ctxt: SyntaxContext::empty().apply_mark(export_mark),\\n src: decl.src,\\n };\\n files.push((src.clone(), file_name));\\n\\n // TODO: Handle rename\\n let mut specifiers = vec![];\\n for s in decl.specifiers {\\n match s {\\n ImportSpecifier::Named(s) => specifiers.push(Specifier::Specific {\\n local: s.local.into(),\\n alias: s.imported.map(From::from),\\n }),\\n ImportSpecifier::Default(s) => specifiers.push(Specifier::Specific {\\n local: s.local.into(),\\n alias: Some(Id::new(js_word!(\"default\"), s.span.ctxt())),\\n }),\\n ImportSpecifier::Namespace(s) => {\\n specifiers.push(Specifier::Namespace {\\n local: s.local.into(),\\n all: forced_ns.contains(&src.src.value),\\n });\\n }\\n }\\n }\\n\\n merged.specifiers.push((src, specifiers));\\n }\\n\\n Ok((merged, files))\\n })\\n }\\n}\\n\\n#[derive(Debug, Default)]\\npub(crate) struct Imports {\\n /// If imported ids are empty, it is a side-effect import.\\n pub specifiers: Vec<(Source, Vec)>,\\n}\\n\\n/// Clone is relatively cheap\\n#[derive(Debug, Clone, Is)]\\npub(crate) enum Specifier {\\n Specific {\\n local: Id,\\n alias: Option,\\n },\\n Namespace {\\n local: Id,\\n /// True for `import * as foo from \\'foo\\'; foo[computedKey()]`\\n all: bool,\\n },\\n}\\n\\n#[derive(Debug, Clone, PartialEq, Eq, Hash)]\\npub(crate) struct Source {\\n pub is_loaded_synchronously: bool,\\n pub is_unconditional: bool,\\n\\n pub module_id: ModuleId,\\n pub local_ctxt: SyntaxContext,\\n pub export_ctxt: SyntaxContext,\\n\\n // Clone is relatively cheap, thanks to string_cache.\\n pub src: Str,\\n}\\n\\nstruct Es6ModuleDetector {\\n /// If import statement or export is detected, it\\'s an es6 module regardless\\n /// of other codes.\\n forced_es6: bool,\\n /// True if other module system is detected.\\n found_other: bool,\\n}\\n\\nimpl Visit for Es6ModuleDetector {\\n noop_visit_type!();\\n\\n fn visit_call_expr(&mut self, e: &CallExpr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match &e.callee {\\n ExprOrSuper::Expr(e) => match &**e {\\n Expr::Ident(Ident {\\n sym: js_word!(\"require\"),\\n ..\\n }) => {\\n self.found_other = true;\\n }\\n _ => {}\\n },\\n ExprOrSuper::Super(_) => {}\\n }\\n }\\n\\n fn visit_member_expr(&mut self, e: &MemberExpr, _: &dyn Node) {\\n e.obj.visit_with(e as _, self);\\n\\n if e.computed {\\n e.prop.visit_with(e as _, self);\\n }\\n\\n match &e.obj {\\n ExprOrSuper::Expr(e) => {\\n match &**e {\\n Expr::Ident(i) => {\\n // TODO: Check syntax context (Check if marker is the global mark)\\n if i.sym == *\"module\" {\\n self.found_other = true;\\n }\\n\\n if i.sym == *\"exports\" {\\n self.found_other = true;\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n _ => {}\\n }\\n\\n //\\n }\\n\\n fn visit_module_decl(&mut self, decl: &ModuleDecl, _: &dyn Node) {\\n match decl {\\n ModuleDecl::Import(_)\\n | ModuleDecl::ExportDecl(_)\\n | ModuleDecl::ExportNamed(_)\\n | ModuleDecl::ExportDefaultDecl(_)\\n | ModuleDecl::ExportDefaultExpr(_)\\n | ModuleDecl::ExportAll(_) => {\\n self.forced_es6 = true;\\n }\\n\\n ModuleDecl::TsImportEquals(_) => {}\\n ModuleDecl::TsExportAssignment(_) => {}\\n ModuleDecl::TsNamespaceExport(_) => {}\\n }\\n }\\n}\\n',\n", + " 'content_id': 'c4abd2d0e292476dbd40dfa92e1a8278f374c626',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/bundler/src/bundler/load.rs',\n", + " 'size': 15564,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6291348600508906,\n", + " 'avg_line_length': 42.666666666666664,\n", + " 'blob_id': '9e088d16cd4d07c1bacdd926fd2a2853d12a5fb3',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_optimization/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_optimization\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.50.0\"\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\ndashmap = \"4.0.2\"\\nindexmap = \"1.6.1\"\\nonce_cell = \"1.5.2\"\\nrayon = { version = \"1.5.1\", optional = true }\\nretain_mut = \"0.1.2\"\\nrustc-hash = \"1.1.0\"\\nserde_json = \"1.0.61\"\\nswc_atoms = {version = \"0.2\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\ntracing = \"0.1.28\"\\n\\n[dev-dependencies]\\nswc_ecma_transforms_compat = {version = \"0.40.0\", path = \"../compat\"}\\nswc_ecma_transforms_module = {version = \"0.44.0\", path = \"../module\"}\\nswc_ecma_transforms_proposal = {version = \"0.44.0\", path = \"../proposal\"}\\nswc_ecma_transforms_react = {version = \"0.46.0\", path = \"../react\"}\\nswc_ecma_transforms_testing = {version = \"0.36.0\", path = \"../testing\"}\\nswc_ecma_transforms_typescript = {version = \"0.46.1\", path = \"../typescript\"}\\ntesting = {version = \"0.14.0\", path = \"../../../testing\"}\\n',\n", + " 'content_id': '778953b1c560d8eb0a1a522e3b5a2513fb16e267',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/transforms/optimization/Cargo.toml',\n", + " 'size': 1572,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4722354509953329,\n", + " 'avg_line_length': 26.592641261498027,\n", + " 'blob_id': 'f8c3b58001f78a62040753d7f69d4375e4d1f77e',\n", + " 'content': 'use self::{\\n ctx::Ctx,\\n storage::{Storage, *},\\n};\\nuse crate::{\\n marks::Marks,\\n util::{can_end_conditionally, idents_used_by, now},\\n};\\nuse rustc_hash::{FxHashMap, FxHashSet};\\nuse std::time::Instant;\\nuse swc_atoms::JsWord;\\nuse swc_common::{SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_type, Node, Visit, VisitWith};\\n\\nmod ctx;\\npub(crate) mod storage;\\n\\npub(crate) fn analyze(n: &N, marks: Option) -> ProgramData\\nwhere\\n N: VisitWith,\\n{\\n analyze_with_storage::(n, marks)\\n}\\n\\n/// TODO: Track assignments to variables via `arguments`.\\n/// TODO: Scope-local. (Including block)\\n///\\n/// If `marks` is [None], markers are ignored.\\npub(crate) fn analyze_with_storage(n: &N, marks: Option) -> S\\nwhere\\n S: Storage,\\n N: VisitWith>,\\n{\\n let start_time = now();\\n\\n let mut v = UsageAnalyzer {\\n data: Default::default(),\\n marks,\\n scope: Default::default(),\\n ctx: Default::default(),\\n };\\n n.visit_with(&Invalid { span: DUMMY_SP }, &mut v);\\n let top_scope = v.scope;\\n v.data.top_scope().merge(top_scope, false);\\n\\n if let Some(start_time) = start_time {\\n let end_time = Instant::now();\\n\\n tracing::debug!(\"Scope analysis took {:?}\", end_time - start_time);\\n }\\n\\n v.data\\n}\\n\\n#[derive(Debug, Default)]\\npub(crate) struct VarUsageInfo {\\n pub inline_prevented: bool,\\n\\n /// The number of reference to this identifier.\\n pub ref_count: usize,\\n\\n /// `true` if a varaible is conditionally initialized.\\n pub cond_init: bool,\\n\\n /// `false` if it\\'s only used.\\n pub declared: bool,\\n pub declared_count: usize,\\n\\n /// `true` if the enclosing function defines this variable as a parameter.\\n pub declared_as_fn_param: bool,\\n\\n pub declared_as_fn_expr: bool,\\n\\n pub assign_count: usize,\\n pub mutation_by_call_count: usize,\\n pub usage_count: usize,\\n\\n /// The variable itself is modified.\\n pub reassigned: bool,\\n /// The variable itself or a property of it is modified.\\n pub mutated: bool,\\n\\n pub has_property_access: bool,\\n pub has_property_mutation: bool,\\n pub accessed_props: FxHashSet,\\n\\n pub exported: bool,\\n /// True if used **above** the declaration. (Not eval order).\\n pub used_above_decl: bool,\\n /// `true` if it\\'s declared by function parameters or variables declared in\\n /// a closest function and used only within it and not used by child\\n /// functions.\\n pub is_fn_local: bool,\\n\\n used_by_nested_fn: bool,\\n\\n pub used_in_loop: bool,\\n\\n pub var_kind: Option,\\n pub var_initialized: bool,\\n\\n pub declared_as_catch_param: bool,\\n\\n pub no_side_effect_for_member_access: bool,\\n\\n pub used_as_callee: bool,\\n\\n /// In `c = b`, `b` inffects `c`.\\n infects: Vec,\\n}\\n\\nimpl VarUsageInfo {\\n pub fn is_mutated_only_by_one_call(&self) -> bool {\\n self.assign_count == 0 && self.mutation_by_call_count == 1\\n }\\n}\\n\\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\\npub(crate) enum ScopeKind {\\n Fn,\\n Block,\\n}\\n\\n#[derive(Debug, Default, Clone)]\\npub(crate) struct ScopeData {\\n pub has_with_stmt: bool,\\n pub has_eval_call: bool,\\n}\\n\\n/// Analyzed info of a whole program we are working on.\\n#[derive(Debug, Default)]\\npub(crate) struct ProgramData {\\n pub vars: FxHashMap,\\n\\n pub top: ScopeData,\\n\\n pub scopes: FxHashMap,\\n}\\n\\n/// This assumes there are no two variable with same name and same span hygiene.\\n#[derive(Debug)]\\npub(crate) struct UsageAnalyzer\\nwhere\\n S: Storage,\\n{\\n data: S,\\n marks: Option,\\n scope: S::ScopeData,\\n ctx: Ctx,\\n}\\n\\nimpl UsageAnalyzer\\nwhere\\n S: Storage,\\n{\\n fn with_child(&mut self, child_ctxt: SyntaxContext, kind: ScopeKind, op: F) -> Ret\\n where\\n F: FnOnce(&mut UsageAnalyzer) -> Ret,\\n {\\n let mut child = UsageAnalyzer {\\n data: Default::default(),\\n marks: self.marks,\\n ctx: self.ctx,\\n scope: Default::default(),\\n };\\n\\n let ret = op(&mut child);\\n {\\n let child_scope = child.data.scope(child_ctxt);\\n\\n child_scope.merge(child.scope, false);\\n }\\n\\n self.data.merge(kind, child.data);\\n\\n ret\\n }\\n\\n fn report_usage(&mut self, i: &Ident, is_assign: bool) {\\n self.data.report_usage(self.ctx, i, is_assign)\\n }\\n\\n fn declare_decl(\\n &mut self,\\n i: &Ident,\\n has_init: bool,\\n kind: Option,\\n _is_fn_decl: bool,\\n ) -> &mut S::VarData {\\n self.scope.add_declared_symbol(i);\\n\\n self.data.declare_decl(self.ctx, i, has_init, kind)\\n }\\n}\\n\\nimpl Visit for UsageAnalyzer\\nwhere\\n S: Storage,\\n{\\n noop_visit_type!();\\n\\n fn visit_await_expr(&mut self, n: &AwaitExpr, _: &dyn Node) {\\n let ctx = Ctx {\\n in_await_arg: true,\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_arrow_expr(&mut self, n: &ArrowExpr, _: &dyn Node) {\\n self.with_child(n.span.ctxt, ScopeKind::Fn, |child| {\\n {\\n let ctx = Ctx {\\n in_pat_of_param: true,\\n ..child.ctx\\n };\\n n.params.visit_with(n, &mut *child.with_ctx(ctx));\\n }\\n\\n match &n.body {\\n BlockStmtOrExpr::BlockStmt(body) => {\\n // We use visit_children_with instead of visit_with to bypass block scope\\n // handler.\\n body.visit_children_with(child);\\n }\\n BlockStmtOrExpr::Expr(body) => {\\n body.visit_with(n, child);\\n }\\n }\\n })\\n }\\n\\n fn visit_assign_expr(&mut self, n: &AssignExpr, _: &dyn Node) {\\n let ctx = Ctx {\\n in_assign_lhs: true,\\n is_exact_reassignment: true,\\n ..self.ctx\\n };\\n n.left.visit_with(n, &mut *self.with_ctx(ctx));\\n\\n let ctx = Ctx {\\n in_assign_lhs: false,\\n is_exact_reassignment: false,\\n ..self.ctx\\n };\\n n.right.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_block_stmt(&mut self, n: &BlockStmt, _: &dyn Node) {\\n self.with_child(n.span.ctxt, ScopeKind::Block, |child| {\\n n.visit_children_with(child);\\n })\\n }\\n\\n fn visit_call_expr(&mut self, n: &CallExpr, _: &dyn Node) {\\n let inline_prevented = self.ctx.inline_prevented\\n || self\\n .marks\\n .map(|marks| n.span.has_mark(marks.noinline))\\n .unwrap_or_default();\\n\\n {\\n let ctx = Ctx {\\n inline_prevented,\\n ..self.ctx\\n };\\n n.callee.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n match &n.callee {\\n ExprOrSuper::Super(_) => {}\\n ExprOrSuper::Expr(callee) => match &**callee {\\n Expr::Ident(callee) => {\\n self.data\\n .var_or_default(callee.to_id())\\n .mark_used_as_callee();\\n }\\n\\n _ => {}\\n },\\n }\\n\\n {\\n let ctx = Ctx {\\n inline_prevented,\\n in_call_arg: true,\\n is_exact_arg: true,\\n is_exact_reassignment: false,\\n ..self.ctx\\n };\\n n.args.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n match &n.callee {\\n ExprOrSuper::Expr(callee) => match &**callee {\\n Expr::Ident(Ident { sym, .. }) if *sym == *\"eval\" => {\\n self.scope.mark_eval_called();\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n fn visit_catch_clause(&mut self, n: &CatchClause, _: &dyn Node) {\\n {\\n let ctx = Ctx {\\n in_cond: true,\\n in_catch_param: true,\\n ..self.ctx\\n };\\n n.param.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n {\\n let ctx = Ctx {\\n in_cond: true,\\n ..self.ctx\\n };\\n n.body.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n }\\n\\n fn visit_class(&mut self, n: &Class, _: &dyn Node) {\\n n.decorators.visit_with(n, self);\\n\\n {\\n let ctx = Ctx {\\n inline_prevented: true,\\n ..self.ctx\\n };\\n n.super_class.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n n.body.visit_with(n, self);\\n }\\n\\n fn visit_class_decl(&mut self, n: &ClassDecl, _: &dyn Node) {\\n self.declare_decl(&n.ident, true, None, false);\\n\\n n.visit_children_with(self);\\n }\\n\\n fn visit_do_while_stmt(&mut self, n: &DoWhileStmt, _: &dyn Node) {\\n let ctx = Ctx {\\n in_loop: true,\\n in_cond: true,\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier, _: &dyn Node) {\\n self.report_usage(&n.orig, false)\\n }\\n\\n fn visit_expr(&mut self, e: &Expr, _: &dyn Node) {\\n e.visit_children_with(self);\\n\\n match e {\\n Expr::Ident(i) => {\\n self.report_usage(i, self.ctx.in_update_arg || self.ctx.in_assign_lhs);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_fn_decl(&mut self, n: &FnDecl, _: &dyn Node) {\\n self.declare_decl(&n.ident, true, None, true);\\n\\n n.visit_children_with(self);\\n }\\n\\n fn visit_fn_expr(&mut self, n: &FnExpr, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if let Some(id) = &n.ident {\\n self.data\\n .var_or_default(id.to_id())\\n .mark_declared_as_fn_expr();\\n }\\n }\\n\\n fn visit_for_in_stmt(&mut self, n: &ForInStmt, _: &dyn Node) {\\n n.right.visit_with(n, self);\\n\\n self.with_child(n.span.ctxt, ScopeKind::Block, |child| {\\n let ctx = Ctx {\\n in_left_of_for_loop: true,\\n is_exact_reassignment: true,\\n ..child.ctx\\n };\\n n.left.visit_with(n, &mut *child.with_ctx(ctx));\\n\\n n.right.visit_with(n, child);\\n\\n let ctx = Ctx {\\n in_loop: true,\\n in_cond: true,\\n ..child.ctx\\n };\\n n.body.visit_with(n, &mut *child.with_ctx(ctx));\\n });\\n }\\n\\n fn visit_for_of_stmt(&mut self, n: &ForOfStmt, _: &dyn Node) {\\n n.right.visit_with(n, self);\\n\\n self.with_child(n.span.ctxt, ScopeKind::Block, |child| {\\n let ctx = Ctx {\\n in_left_of_for_loop: true,\\n is_exact_reassignment: true,\\n ..child.ctx\\n };\\n n.left.visit_with(n, &mut *child.with_ctx(ctx));\\n\\n let ctx = Ctx {\\n in_loop: true,\\n in_cond: true,\\n ..child.ctx\\n };\\n n.body.visit_with(n, &mut *child.with_ctx(ctx))\\n });\\n }\\n\\n fn visit_for_stmt(&mut self, n: &ForStmt, _: &dyn Node) {\\n n.init.visit_with(n, self);\\n\\n let ctx = Ctx {\\n in_loop: true,\\n in_cond: true,\\n ..self.ctx\\n };\\n\\n n.test.visit_with(n, &mut *self.with_ctx(ctx));\\n n.update.visit_with(n, &mut *self.with_ctx(ctx));\\n\\n n.body.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_function(&mut self, n: &Function, _: &dyn Node) {\\n n.decorators.visit_with(n, self);\\n\\n let is_standalone = self\\n .marks\\n .map(|marks| n.span.has_mark(marks.standalone))\\n .unwrap_or_default();\\n\\n // We don\\'t dig into standalone function, as it does not share any variable with\\n // outer scope.\\n if self.ctx.skip_standalone && is_standalone {\\n return;\\n }\\n\\n let ctx = Ctx {\\n skip_standalone: self.ctx.skip_standalone || is_standalone,\\n ..self.ctx\\n };\\n\\n self.with_ctx(ctx)\\n .with_child(n.span.ctxt, ScopeKind::Fn, |child| {\\n n.params.visit_with(n, child);\\n\\n match &n.body {\\n Some(body) => {\\n // We use visit_children_with instead of visit_with to bypass block scope\\n // handler.\\n body.visit_children_with(child);\\n }\\n None => {}\\n }\\n })\\n }\\n\\n fn visit_if_stmt(&mut self, n: &IfStmt, _: &dyn Node) {\\n let ctx = Ctx {\\n in_cond: true,\\n ..self.ctx\\n };\\n n.test.visit_with(n, self);\\n n.cons.visit_with(n, &mut *self.with_ctx(ctx));\\n n.alt.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier, _: &dyn Node) {\\n self.declare_decl(&n.local, true, None, false);\\n }\\n\\n fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier, _: &dyn Node) {\\n self.declare_decl(&n.local, true, None, false);\\n }\\n\\n fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier, _: &dyn Node) {\\n self.declare_decl(&n.local, true, None, false);\\n }\\n\\n fn visit_member_expr(&mut self, e: &MemberExpr, _: &dyn Node) {\\n {\\n let ctx = Ctx {\\n is_exact_arg: false,\\n is_exact_reassignment: false,\\n ..self.ctx\\n };\\n e.obj\\n .visit_with(&Invalid { span: DUMMY_SP }, &mut *self.with_ctx(ctx));\\n }\\n\\n if e.computed {\\n let ctx = Ctx {\\n is_exact_arg: false,\\n is_exact_reassignment: false,\\n ..self.ctx\\n };\\n e.prop\\n .visit_with(&Invalid { span: DUMMY_SP }, &mut *self.with_ctx(ctx));\\n }\\n\\n match &e.obj {\\n ExprOrSuper::Super(_) => {}\\n ExprOrSuper::Expr(obj) => match &**obj {\\n Expr::Ident(obj) => {\\n let v = self.data.var_or_default(obj.to_id());\\n v.mark_has_property_access();\\n\\n if self.ctx.in_assign_lhs {\\n v.mark_has_property_mutation();\\n }\\n\\n if !e.computed {\\n match &*e.prop {\\n Expr::Ident(prop) => {\\n v.add_accessed_property(prop.sym.clone());\\n }\\n _ => {}\\n }\\n }\\n }\\n _ => {}\\n },\\n }\\n }\\n\\n fn visit_module(&mut self, n: &Module, _: &dyn Node) {\\n let ctx = Ctx {\\n skip_standalone: true,\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx))\\n }\\n\\n fn visit_named_export(&mut self, n: &NamedExport, _: &dyn Node) {\\n if n.src.is_some() {\\n return;\\n }\\n n.visit_children_with(self);\\n }\\n\\n fn visit_new_expr(&mut self, n: &NewExpr, _: &dyn Node) {\\n {\\n n.callee.visit_with(n, self);\\n let ctx = Ctx {\\n in_call_arg: true,\\n is_exact_arg: true,\\n ..self.ctx\\n };\\n n.args.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n }\\n\\n fn visit_param(&mut self, n: &Param, _: &dyn Node) {\\n let ctx = Ctx {\\n in_pat_of_param: false,\\n ..self.ctx\\n };\\n n.decorators.visit_with(n, &mut *self.with_ctx(ctx));\\n\\n let ctx = Ctx {\\n in_pat_of_param: true,\\n var_decl_kind_of_pat: None,\\n ..self.ctx\\n };\\n n.pat.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_pat(&mut self, n: &Pat, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n let Ctx {\\n in_left_of_for_loop,\\n in_pat_of_param,\\n ..\\n } = self.ctx;\\n\\n match n {\\n Pat::Ident(i) => {\\n if self.ctx.in_pat_of_var_decl\\n || self.ctx.in_pat_of_param\\n || self.ctx.in_catch_param\\n {\\n let v = self.declare_decl(\\n &i.id,\\n self.ctx.in_pat_of_var_decl_with_init,\\n self.ctx.var_decl_kind_of_pat,\\n false,\\n );\\n\\n if in_pat_of_param {\\n v.mark_declared_as_fn_param();\\n }\\n\\n if in_left_of_for_loop {\\n v.mark_reassigned();\\n v.mark_mutated();\\n }\\n } else {\\n self.report_usage(&i.id, true);\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_prop(&mut self, n: &Prop, _: &dyn Node) {\\n let ctx = Ctx {\\n in_update_arg: false,\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n\\n match n {\\n Prop::Shorthand(i) => {\\n self.report_usage(i, false);\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_setter_prop(&mut self, n: &SetterProp, _: &dyn Node) {\\n self.with_child(n.span.ctxt, ScopeKind::Fn, |a| {\\n n.key.visit_with(n, a);\\n {\\n let ctx = Ctx {\\n in_pat_of_param: true,\\n ..a.ctx\\n };\\n n.param.visit_with(n, &mut *a.with_ctx(ctx));\\n }\\n\\n n.body.visit_with(n, a);\\n });\\n }\\n\\n fn visit_stmt(&mut self, n: &Stmt, _: &dyn Node) {\\n let ctx = Ctx {\\n in_update_arg: false,\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_stmts(&mut self, stmts: &[Stmt], _: &dyn Node) {\\n let mut had_cond = false;\\n\\n for stmt in stmts {\\n let ctx = Ctx {\\n in_cond: self.ctx.in_cond || had_cond,\\n ..self.ctx\\n };\\n\\n stmt.visit_with(&Invalid { span: DUMMY_SP }, &mut *self.with_ctx(ctx));\\n\\n had_cond |= can_end_conditionally(stmt);\\n }\\n }\\n\\n fn visit_switch_case(&mut self, n: &SwitchCase, _: &dyn Node) {\\n n.test.visit_with(n, self);\\n\\n {\\n let ctx = Ctx {\\n in_cond: true,\\n ..self.ctx\\n };\\n n.cons.visit_with(n, &mut *self.with_ctx(ctx));\\n }\\n }\\n\\n fn visit_try_stmt(&mut self, n: &TryStmt, _: &dyn Node) {\\n let ctx = Ctx {\\n in_cond: true,\\n ..self.ctx\\n };\\n\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_update_expr(&mut self, n: &UpdateExpr, _: &dyn Node) {\\n let ctx = Ctx {\\n in_update_arg: true,\\n is_exact_reassignment: true,\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_var_decl(&mut self, n: &VarDecl, _: &dyn Node) {\\n let ctx = Ctx {\\n var_decl_kind_of_pat: Some(n.kind),\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n\\n for decl in &n.decls {\\n match (&decl.name, decl.init.as_deref()) {\\n (Pat::Ident(var), Some(init)) => {\\n let used_idents = idents_used_by(init);\\n\\n for id in used_idents {\\n self.data\\n .var_or_default(id.clone())\\n .add_infects(var.to_id());\\n\\n self.data.var_or_default(var.to_id()).add_infects(id);\\n }\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_var_declarator(&mut self, e: &VarDeclarator, _: &dyn Node) {\\n let ctx = Ctx {\\n in_pat_of_var_decl: true,\\n in_pat_of_var_decl_with_init: e.init.is_some(),\\n in_var_decl_with_no_side_effect_for_member_access: match e.init.as_deref() {\\n Some(Expr::Array(..) | Expr::Lit(..)) => true,\\n _ => false,\\n },\\n ..self.ctx\\n };\\n e.name.visit_with(e, &mut *self.with_ctx(ctx));\\n\\n e.init.visit_with(e, self);\\n }\\n\\n fn visit_while_stmt(&mut self, n: &WhileStmt, _: &dyn Node) {\\n let ctx = Ctx {\\n in_loop: true,\\n in_cond: true,\\n ..self.ctx\\n };\\n n.visit_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_with_stmt(&mut self, n: &WithStmt, _: &dyn Node) {\\n self.scope.mark_with_stmt();\\n n.visit_children_with(self);\\n }\\n}\\n',\n", + " 'content_id': '76917382a63789990918278aff9a187d152632f0',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 97,\n", + " 'path': '/ecmascript/minifier/src/analyzer/mod.rs',\n", + " 'size': 20998,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5143440421188353,\n", + " 'avg_line_length': 30.764505119453926,\n", + " 'blob_id': '6224fd08b4bbe01d4a6fc0fea5e5e4c394e79e7e',\n", + " 'content': 'use anyhow::{bail, Context, Error};\\nuse path_clean::PathClean;\\nuse reqwest::Url;\\nuse sha1::{Digest, Sha1};\\nuse std::{\\n env::current_dir,\\n fs::{create_dir_all, read_to_string, write},\\n io::Write,\\n path::{Path, PathBuf},\\n};\\nuse swc_bundler::{Load, ModuleData, Resolve};\\nuse swc_common::{\\n comments::SingleThreadedComments,\\n errors::{ColorConfig, Handler},\\n sync::Lrc,\\n FileName, Mark, SourceMap,\\n};\\nuse swc_ecma_parser::{lexer::Lexer, JscTarget, Parser, StringInput, Syntax, TsConfig};\\nuse swc_ecma_transforms::{react, typescript::strip};\\nuse swc_ecma_visit::FoldWith;\\npub struct Loader {\\n pub cm: Lrc,\\n}\\n\\nfn calc_hash(s: &str) -> String {\\n let mut hasher = Sha1::new();\\n hasher.update(s.as_bytes());\\n let sum = hasher.finalize();\\n\\n hex::encode(sum)\\n}\\n\\nfn calc_cache_path(cache_dir: &Path, url: &Url) -> PathBuf {\\n let hash = calc_hash(&url.to_string());\\n let s = url.to_string();\\n if s.starts_with(\"https://deno.land/\") {\\n return cache_dir.join(\"deno\").join(&hash);\\n }\\n\\n cache_dir.join(\"untrusted\").join(hash)\\n}\\n\\n/// Load url. This method does caching.\\nfn load_url(url: Url) -> Result {\\n let cache_dir = PathBuf::from(\\n current_dir()\\n .expect(\"the test requires an environment variable named `CARGO_MANIFEST_DIR`\"),\\n )\\n .join(\"tests\")\\n .join(\".cache\");\\n\\n let cache_path = calc_cache_path(&cache_dir, &url).with_extension(\"ts\");\\n\\n create_dir_all(cache_path.parent().unwrap()).context(\"failed to create cache dir\")?;\\n\\n match read_to_string(&cache_path) {\\n Ok(v) => return Ok(v),\\n _ => {}\\n }\\n\\n if let Ok(\"1\") = std::env::var(\"CI\").as_deref() {\\n panic!(\"The bundler test suite should not download files from CI\")\\n }\\n\\n eprintln!(\"Storing `{}` at `{}`\", url, cache_path.display());\\n\\n let resp = reqwest::blocking::get(url.clone())\\n .with_context(|| format!(\"failed to fetch `{}`\", url))?;\\n\\n let bytes = resp\\n .bytes()\\n .with_context(|| format!(\"failed to read data from `{}`\", url))?;\\n\\n let mut content = vec![];\\n write!(content, \"// Loaded from {}\\\\n\\\\n\\\\n\", url).unwrap();\\n content.extend_from_slice(&bytes);\\n\\n write(&cache_path, &content)?;\\n\\n return Ok(String::from_utf8_lossy(&bytes).to_string());\\n}\\n\\nimpl Load for Loader {\\n fn load(&self, f: &FileName) -> Result {\\n eprintln!(\"load: {}\", f);\\n\\n let top_level_mark = Mark::fresh(Mark::root());\\n\\n let tsx;\\n let fm = match f {\\n FileName::Real(path) => {\\n tsx = path.to_string_lossy().ends_with(\".tsx\");\\n self.cm.load_file(&path)?\\n }\\n FileName::Custom(url) => {\\n tsx = url.ends_with(\".tsx\");\\n // Hack for jszip, which depends on invalid url.\\n let url = url.replace(\"https://deno.land/std@v\", \"https://deno.land/std@\");\\n\\n let url = Url::parse(&url).context(\"failed to parse url\")?;\\n\\n let src = load_url(url.clone())?;\\n\\n self.cm\\n .new_source_file(FileName::Custom(url.to_string()), src.to_string())\\n }\\n _ => unreachable!(),\\n };\\n\\n let lexer = Lexer::new(\\n Syntax::Typescript(TsConfig {\\n decorators: true,\\n tsx,\\n dynamic_import: true,\\n ..Default::default()\\n }),\\n JscTarget::Es2020,\\n StringInput::from(&*fm),\\n None,\\n );\\n\\n let mut parser = Parser::new_from(lexer);\\n let module = parser.parse_module().unwrap_or_else(|err| {\\n let handler =\\n Handler::with_tty_emitter(ColorConfig::Always, false, false, Some(self.cm.clone()));\\n err.into_diagnostic(&handler).emit();\\n panic!(\"failed to parse\")\\n });\\n let module = module\\n .fold_with(&mut strip())\\n .fold_with(&mut react::react::(\\n self.cm.clone(),\\n None,\\n Default::default(),\\n top_level_mark,\\n ));\\n\\n Ok(ModuleData {\\n fm,\\n module,\\n helpers: Default::default(),\\n })\\n }\\n}\\n\\npub struct NodeResolver;\\n\\nstatic EXTENSIONS: &[&str] = &[\"ts\", \"tsx\", \"js\", \"jsx\", \"json\", \"node\"];\\n\\nimpl NodeResolver {\\n fn wrap(&self, path: PathBuf) -> Result {\\n let path = path.clean();\\n Ok(FileName::Real(path))\\n }\\n\\n /// Resolve a path as a file. If `path` refers to a file, it is\\n /// returned; otherwise the `path` + each extension is tried.\\n fn resolve_as_file(&self, path: &Path) -> Result {\\n // 1. If X is a file, load X as JavaScript text.\\n if path.is_file() {\\n return Ok(path.to_path_buf());\\n }\\n\\n for ext in EXTENSIONS {\\n let ext_path = path.with_extension(ext);\\n if ext_path.is_file() {\\n return Ok(ext_path);\\n }\\n }\\n\\n bail!(\"file not found: {}\", path.display())\\n }\\n\\n /// Resolve a path as a directory, using the \"main\" key from a\\n /// package.json file if it exists, or resolving to the\\n /// index.EXT file if it exists.\\n fn resolve_as_directory(&self, path: &PathBuf) -> Result {\\n // 1. If X/package.json is a file, use it.\\n let pkg_path = path.join(\"package.json\");\\n if pkg_path.is_file() {\\n let main = self.resolve_package_main(&pkg_path);\\n if main.is_ok() {\\n return main;\\n }\\n }\\n\\n // 2. LOAD_INDEX(X)\\n self.resolve_index(path)\\n }\\n\\n /// Resolve using the package.json \"main\" key.\\n fn resolve_package_main(&self, _: &PathBuf) -> Result {\\n bail!(\"package.json is not supported\")\\n }\\n\\n /// Resolve a directory to its index.EXT.\\n fn resolve_index(&self, path: &PathBuf) -> Result {\\n // 1. If X/index.js is a file, load X/index.js as JavaScript text.\\n // 2. If X/index.json is a file, parse X/index.json to a JavaScript object.\\n // 3. If X/index.node is a file, load X/index.node as binary addon.\\n for ext in EXTENSIONS {\\n let ext_path = path.join(format!(\"index.{}\", ext));\\n if ext_path.is_file() {\\n return Ok(ext_path);\\n }\\n }\\n\\n bail!(\"index not found: {}\", path.display())\\n }\\n\\n /// Resolve by walking up node_modules folders.\\n fn resolve_node_modules(&self, base_dir: &Path, target: &str) -> Result {\\n let node_modules = base_dir.join(\"node_modules\");\\n if node_modules.is_dir() {\\n let path = node_modules.join(target);\\n let result = self\\n .resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path));\\n if result.is_ok() {\\n return result;\\n }\\n }\\n\\n match base_dir.parent() {\\n Some(parent) => self.resolve_node_modules(parent, target),\\n None => bail!(\"not found\"),\\n }\\n }\\n}\\n\\nimpl Resolve for NodeResolver {\\n fn resolve(&self, base: &FileName, target: &str) -> Result {\\n match Url::parse(target) {\\n Ok(v) => return Ok(FileName::Custom(v.to_string())),\\n Err(_) => {}\\n }\\n\\n let base = match base {\\n FileName::Real(v) => v,\\n FileName::Custom(base_url) => {\\n let base_url = Url::parse(&base_url).context(\"failed to parse url\")?;\\n\\n let options = Url::options();\\n let base_url = options.base_url(Some(&base_url));\\n let url = base_url\\n .parse(target)\\n .with_context(|| format!(\"failed to resolve `{}`\", target))?;\\n\\n return Ok(FileName::Custom(url.to_string()));\\n }\\n _ => bail!(\"node-resolver supports only files\"),\\n };\\n\\n // Absolute path\\n if target.starts_with(\"/\") {\\n let base_dir = &Path::new(\"/\");\\n\\n let path = base_dir.join(target);\\n return self\\n .resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path))\\n .and_then(|p| self.wrap(p));\\n }\\n\\n let cwd = &Path::new(\".\");\\n let mut base_dir = base.parent().unwrap_or(&cwd);\\n\\n if target.starts_with(\"./\") || target.starts_with(\"../\") {\\n let win_target;\\n let target = if cfg!(target_os = \"windows\") {\\n let t = if target.starts_with(\"./\") {\\n &target[2..]\\n } else {\\n base_dir = base_dir.parent().unwrap();\\n &target[3..]\\n };\\n win_target = t.replace(\"/\", \"\\\\\\\\\");\\n &*win_target\\n } else {\\n target\\n };\\n\\n let path = base_dir.join(target);\\n return self\\n .resolve_as_file(&path)\\n .or_else(|_| self.resolve_as_directory(&path))\\n .and_then(|p| self.wrap(p));\\n }\\n\\n self.resolve_node_modules(base_dir, target)\\n .and_then(|p| self.wrap(p))\\n }\\n}\\n',\n", + " 'content_id': '9afa8d3678ca8e095f96080bfcb2f632bba3810f',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/bundler/tests/common/mod.rs',\n", + " 'size': 9307,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5566433566433566,\n", + " 'avg_line_length': 25.0,\n", + " 'blob_id': 'f14287e2548cd86d7333f33892c99cdb6d4e71bd',\n", + " 'content': \"use crate::util::fast_graph::FastDiGraphMap;\\nuse petgraph::{\\n EdgeDirection,\\n EdgeDirection::{Incoming, Outgoing},\\n};\\nuse rustc_hash::FxHashSet;\\nuse std::{collections::VecDeque, iter::repeat};\\n\\n/// Is dependancy between nodes hard?\\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]\\npub(super) enum Required {\\n /// Required to evaluate\\n Always,\\n\\n /// Maybe required to evaluate\\n Maybe,\\n}\\n\\n/// Used to debug petgraph.\\n#[derive(Debug, Default)]\\npub(super) struct StmtDepGraph {\\n inner: FastDiGraphMap,\\n /// Read-optimized hashset which contains all direct dependencies and\\n /// transitive dependencies.\\n paths: Vec>,\\n}\\n\\nimpl StmtDepGraph {\\n pub fn node_count(&self) -> usize {\\n self.inner.node_count()\\n }\\n\\n pub fn add_node(&mut self, node: usize) {\\n self.inner.add_node(node);\\n }\\n\\n pub fn remove_node(&mut self, node: usize) {\\n self.inner.add_node(node);\\n }\\n\\n pub fn add_edge(&mut self, a: usize, b: usize, required: Required) {\\n self.inner.add_edge(a, b, required);\\n\\n self.insert_transitives(a, b);\\n }\\n\\n fn calc_transitives(&self, id: usize, dir: EdgeDirection) -> FxHashSet {\\n let mut set = FxHashSet::default();\\n\\n let mut queue = VecDeque::default();\\n queue.push_front(id);\\n\\n while let Some(id) = queue.pop_front() {\\n // Already processed\\n if !set.insert(id) {\\n continue;\\n }\\n\\n for transitive in self.inner.neighbors_directed(id, dir) {\\n queue.push_back(transitive);\\n }\\n }\\n\\n set\\n }\\n\\n fn insert_transitives(&mut self, from: usize, to: usize) {\\n if self.paths.len() <= from {\\n self.paths\\n .extend(repeat(Default::default()).take(from + 1 - self.paths.len()))\\n }\\n if !self.paths[from].insert(to) {\\n return;\\n }\\n\\n for transitive in self.calc_transitives(to, Outgoing) {\\n if from == transitive {\\n continue;\\n }\\n self.paths[from].insert(transitive);\\n }\\n\\n for transitive in self.calc_transitives(from, Incoming) {\\n if to == transitive {\\n continue;\\n }\\n\\n self.paths[transitive].insert(to);\\n }\\n }\\n\\n pub fn edge_weight(&self, a: usize, b: usize) -> Option {\\n self.inner.edge_weight(a, b).cloned()\\n }\\n\\n pub fn neighbors_directed<'a>(\\n &'a self,\\n start: usize,\\n dir: EdgeDirection,\\n ) -> impl 'a + Iterator {\\n self.inner.neighbors_directed(start, dir)\\n }\\n\\n pub fn has_a_path(&self, from: usize, to: usize) -> bool {\\n match self.paths.get(from) {\\n Some(ps) => ps.contains(&to),\\n None => false,\\n }\\n }\\n}\\n\",\n", + " 'content_id': 'ecefcdd860acb9097b51fc1a98a0361df11787c7',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 85,\n", + " 'path': '/bundler/src/modules/sort/graph.rs',\n", + " 'size': 2860,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5149504765464399,\n", + " 'avg_line_length': 28.32054794520548,\n", + " 'blob_id': '6d6960b683c4e86bbe5839d22c7dde7d6b98cfe5',\n", + " 'content': 'use crate::scope::{IdentType, ScopeKind};\\nuse rustc_hash::FxHashSet;\\nuse std::cell::RefCell;\\nuse swc_atoms::JsWord;\\nuse swc_common::{Mark, SyntaxContext};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{find_ids, Id};\\nuse swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\n\\n#[cfg(test)]\\nmod tests;\\n\\nconst LOG: bool = false;\\n\\n/// See [resolver_with_mark] for docs.\\npub fn resolver() -> impl \\'static + Fold + VisitMut {\\n resolver_with_mark(Mark::fresh(Mark::root()))\\n}\\n\\n/// # When to run\\n///\\n/// The resolver expects \\'clean\\' ast. You can get clean ast by parsing, or by\\n/// removing all syntax context in ast nodes.\\n///\\n/// # What does it do\\n///\\n/// Firstly all scopes (fn, block) has it\\'s own SyntaxContext.\\n/// Resolver visits all identifiers in module, and look for binding identifies\\n/// in the scope. Those identifiers now have the SyntaxContext of scope (fn,\\n/// block). While doing so, resolver tries to resolve normal identifiers (no\\n/// hygiene info) as a reference to identifier of scope. If the resolver find\\n/// suitable variable, the identifier reference will have same context as the\\n/// variable.\\n///\\n///\\n/// # Panics\\n///\\n/// `top_level_mark` should not be root.\\n///\\n/// # Example\\n///\\n/// ```js\\n/// let a = 1;\\n/// {\\n/// let a = 2;\\n/// use(a);\\n/// }\\n/// use(a)\\n/// ```\\n///\\n/// resolver does\\n///\\n/// 1. Define `a` with top level context.\\n///\\n/// 2. Found a block, so visit block with a new syntax context.\\n///\\n/// 3. Defined `a` with syntax context of the block statement.\\n////\\n/// 4. Found usage of `a`, and determines that it\\'s reference to `a` in the\\n/// block. So the reference to `a` will have same syntax context as `a` in the\\n/// block.\\n///\\n/// 5. Found usage of `a` (last line), and determines that it\\'s a\\n/// reference to top-level `a`, and change syntax context of `a` on last line to\\n/// top-level syntax context.\\npub fn resolver_with_mark(top_level_mark: Mark) -> impl \\'static + Fold + VisitMut {\\n assert_ne!(\\n top_level_mark,\\n Mark::root(),\\n \"Marker provided to resolver should not be the root mark\"\\n );\\n as_folder(Resolver::new(\\n top_level_mark,\\n Scope::new(ScopeKind::Fn, None),\\n false,\\n ))\\n}\\n\\n/// [resolver_with_mark] with typescript support enabled.\\npub fn ts_resolver(top_level_mark: Mark) -> impl \\'static + Fold + VisitMut {\\n assert_ne!(\\n top_level_mark,\\n Mark::root(),\\n \"Marker provided to resolver should not be the root mark\"\\n );\\n as_folder(Resolver::new(\\n top_level_mark,\\n Scope::new(ScopeKind::Fn, None),\\n true,\\n ))\\n}\\n\\n#[derive(Debug, Clone)]\\nstruct Scope<\\'a> {\\n /// Parent scope of the scope\\n parent: Option<&\\'a Scope<\\'a>>,\\n\\n /// Kind of the scope.\\n kind: ScopeKind,\\n\\n /// All declarations in the scope\\n declared_symbols: FxHashSet,\\n hoisted_symbols: RefCell>,\\n\\n /// All types declared in the scope\\n declared_types: FxHashSet,\\n}\\n\\nimpl<\\'a> Default for Scope<\\'a> {\\n fn default() -> Self {\\n Scope::new(ScopeKind::Fn, None)\\n }\\n}\\n\\nimpl<\\'a> Scope<\\'a> {\\n pub fn new(kind: ScopeKind, parent: Option<&\\'a Scope<\\'a>>) -> Self {\\n Scope {\\n parent,\\n kind,\\n declared_symbols: Default::default(),\\n hoisted_symbols: Default::default(),\\n declared_types: Default::default(),\\n }\\n }\\n}\\n\\n/// # Phases\\n///\\n/// ## Hoisting phase\\n///\\n/// ## Resolving phase\\nstruct Resolver<\\'a> {\\n hoist: bool,\\n mark: Mark,\\n current: Scope<\\'a>,\\n ident_type: IdentType,\\n handle_types: bool,\\n in_type: bool,\\n in_ts_module: bool,\\n}\\n\\nimpl<\\'a> Resolver<\\'a> {\\n fn new(mark: Mark, current: Scope<\\'a>, handle_types: bool) -> Self {\\n Resolver {\\n hoist: false,\\n mark,\\n current,\\n ident_type: IdentType::Ref,\\n handle_types,\\n in_type: false,\\n in_ts_module: false,\\n }\\n }\\n\\n fn visit_mut_stmt_within_child_scope(&mut self, s: &mut Stmt) {\\n let child_mark = Mark::fresh(self.mark);\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Block, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n child.visit_mut_stmt_within_same_scope(s)\\n }\\n\\n fn visit_mut_stmt_within_same_scope(&mut self, s: &mut Stmt) {\\n match s {\\n Stmt::Block(s) => {\\n s.visit_mut_children_with(self);\\n }\\n _ => s.visit_mut_with(self),\\n }\\n }\\n\\n /// Returns a [Mark] for an identifier reference.\\n fn mark_for_ref(&self, sym: &JsWord) -> Option {\\n if self.handle_types && self.in_type {\\n let mut mark = self.mark;\\n let mut scope = Some(&self.current);\\n\\n while let Some(cur) = scope {\\n // if cur.declared_types.contains(sym) ||\\n // cur.hoisted_symbols.borrow().contains(sym) {\\n if cur.declared_types.contains(sym) {\\n if mark == Mark::root() {\\n break;\\n }\\n return Some(mark);\\n }\\n mark = mark.parent();\\n scope = cur.parent;\\n }\\n }\\n\\n let mut mark = self.mark;\\n let mut scope = Some(&self.current);\\n\\n while let Some(cur) = scope {\\n if cur.declared_symbols.contains(sym) || cur.hoisted_symbols.borrow().contains(sym) {\\n if mark == Mark::root() {\\n return None;\\n }\\n return Some(mark);\\n }\\n mark = mark.parent();\\n scope = cur.parent;\\n }\\n\\n None\\n }\\n\\n /// Modifies a binding identifier.\\n fn modify(&mut self, ident: &mut Ident, kind: Option) {\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\\n \"resolver: Binding (type = {}) {}{:?} {:?}\",\\n self.in_type,\\n ident.sym,\\n ident.span.ctxt(),\\n kind\\n );\\n }\\n\\n if ident.span.ctxt() != SyntaxContext::empty() {\\n return;\\n }\\n\\n if self.in_type {\\n self.current.declared_types.insert(ident.sym.clone());\\n let mark = self.mark;\\n\\n ident.span = if mark == Mark::root() {\\n ident.span\\n } else {\\n let span = ident.span.apply_mark(mark);\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\t-> {:?}\", span.ctxt());\\n }\\n span\\n };\\n return;\\n }\\n\\n if self.hoist {\\n // If there\\'s no binding with same name, it means the code depends on hoisting\\n //\\n // e.g.\\n //\\n // function test() {\\n // if (typeof Missing == typeof EXTENDS) {\\n // console.log(\"missing\")\\n // }\\n // var EXTENDS = \"test\";\\n // }\\n let val = (|| {\\n let mut cursor = Some(&self.current);\\n let mut mark = self.mark;\\n\\n while let Some(c) = cursor {\\n if c.declared_symbols.contains(&ident.sym)\\n || c.hoisted_symbols.borrow().contains(&ident.sym)\\n {\\n c.hoisted_symbols.borrow_mut().insert(ident.sym.clone());\\n return None;\\n }\\n cursor = c.parent;\\n let m = mark.parent();\\n if m == Mark::root() {\\n return Some(mark);\\n }\\n mark = m;\\n }\\n\\n None\\n })();\\n if let Some(mark) = val {\\n ident.span = ident.span.apply_mark(mark);\\n return;\\n }\\n }\\n\\n let mut mark = self.mark;\\n\\n if self.hoist {\\n let mut cursor = Some(&self.current);\\n\\n match kind {\\n Some(VarDeclKind::Var) | None => {\\n while let Some(c) = cursor {\\n if c.kind == ScopeKind::Fn {\\n c.hoisted_symbols.borrow_mut().insert(ident.sym.clone());\\n break;\\n }\\n cursor = c.parent;\\n mark = mark.parent();\\n }\\n }\\n Some(VarDeclKind::Let) | Some(VarDeclKind::Const) => {\\n self.current\\n .hoisted_symbols\\n .borrow_mut()\\n .insert(ident.sym.clone());\\n }\\n }\\n } else {\\n self.current.declared_symbols.insert(ident.sym.clone());\\n }\\n\\n ident.span = if mark == Mark::root() {\\n ident.span\\n } else {\\n let span = ident.span.apply_mark(mark);\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\t-> {:?}\", span.ctxt());\\n }\\n span\\n };\\n }\\n}\\n\\nmacro_rules! typed {\\n ($name:ident, $T:ty) => {\\n fn $name(&mut self, node: &mut $T) {\\n if self.handle_types {\\n self.in_type = true;\\n node.visit_mut_children_with(self)\\n }\\n }\\n };\\n}\\n\\nmacro_rules! typed_ref {\\n ($name:ident, $T:ty) => {\\n fn $name(&mut self, node: &mut $T) {\\n if self.handle_types {\\n self.ident_type = IdentType::Ref;\\n self.in_type = true;\\n node.visit_mut_children_with(self)\\n }\\n }\\n };\\n}\\n\\nmacro_rules! typed_decl {\\n ($name:ident, $T:ty) => {\\n fn $name(&mut self, node: &mut $T) {\\n if self.handle_types {\\n self.ident_type = IdentType::Binding;\\n self.in_type = true;\\n node.visit_mut_children_with(self)\\n }\\n }\\n };\\n}\\n\\nmacro_rules! noop {\\n ($name:ident, $T:ty) => {\\n #[inline]\\n fn $name(&mut self, _: &mut $T) {}\\n };\\n}\\n\\nimpl<\\'a> VisitMut for Resolver<\\'a> {\\n noop!(visit_mut_accessibility, Accessibility);\\n noop!(visit_mut_true_plus_minus, TruePlusMinus);\\n noop!(visit_mut_ts_keyword_type, TsKeywordType);\\n noop!(visit_mut_ts_keyword_type_kind, TsKeywordTypeKind);\\n noop!(visit_mut_ts_type_operator_op, TsTypeOperatorOp);\\n noop!(visit_mut_ts_enum_member_id, TsEnumMemberId);\\n noop!(visit_mut_ts_external_module_ref, TsExternalModuleRef);\\n noop!(visit_mut_ts_module_name, TsModuleName);\\n noop!(visit_mut_ts_this_type, TsThisType);\\n\\n typed_ref!(visit_mut_ts_array_type, TsArrayType);\\n typed_ref!(visit_mut_ts_conditional_type, TsConditionalType);\\n typed_ref!(visit_mut_ts_entity_name, TsEntityName);\\n typed_ref!(\\n visit_mut_ts_type_param_instantiation,\\n TsTypeParamInstantiation\\n );\\n typed_ref!(visit_mut_ts_type_query, TsTypeQuery);\\n typed_ref!(visit_mut_ts_type_query_expr, TsTypeQueryExpr);\\n typed_ref!(visit_mut_ts_type_operator, TsTypeOperator);\\n typed_ref!(visit_mut_ts_type, TsType);\\n typed_ref!(visit_mut_ts_type_ann, TsTypeAnn);\\n typed_ref!(visit_mut_ts_type_assertion, TsTypeAssertion);\\n typed!(\\n visit_mut_ts_union_or_intersection_type,\\n TsUnionOrIntersectionType\\n );\\n typed!(visit_mut_ts_fn_or_constructor_type, TsFnOrConstructorType);\\n typed_ref!(visit_mut_ts_union_type, TsUnionType);\\n typed_ref!(visit_mut_ts_infer_type, TsInferType);\\n typed_ref!(visit_mut_ts_import_type, TsImportType);\\n typed_ref!(visit_mut_ts_tuple_type, TsTupleType);\\n typed_ref!(visit_mut_ts_intersection_type, TsIntersectionType);\\n typed_ref!(visit_mut_ts_type_ref, TsTypeRef);\\n typed_decl!(visit_mut_ts_type_param_decl, TsTypeParamDecl);\\n typed!(visit_mut_ts_enum_member, TsEnumMember);\\n typed!(visit_mut_ts_fn_param, TsFnParam);\\n typed!(visit_mut_ts_indexed_access_type, TsIndexedAccessType);\\n typed!(visit_mut_ts_index_signature, TsIndexSignature);\\n typed!(visit_mut_ts_interface_body, TsInterfaceBody);\\n typed!(visit_mut_ts_module_ref, TsModuleRef);\\n typed!(visit_mut_ts_parenthesized_type, TsParenthesizedType);\\n typed!(visit_mut_ts_type_lit, TsTypeLit);\\n typed!(visit_mut_ts_type_element, TsTypeElement);\\n typed!(visit_mut_ts_module_block, TsModuleBlock);\\n typed!(visit_mut_ts_namespace_body, TsNamespaceBody);\\n typed!(visit_mut_ts_optional_type, TsOptionalType);\\n typed!(visit_mut_ts_param_prop, TsParamProp);\\n typed!(visit_mut_ts_rest_type, TsRestType);\\n typed!(visit_mut_ts_type_predicate, TsTypePredicate);\\n typed_ref!(visit_mut_ts_this_type_or_ident, TsThisTypeOrIdent);\\n\\n fn visit_mut_import_decl(&mut self, n: &mut ImportDecl) {\\n if n.type_only {\\n if !self.handle_types {\\n return;\\n }\\n }\\n\\n self.ident_type = IdentType::Binding;\\n self.in_type = n.type_only;\\n n.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_arrow_expr(&mut self, e: &mut ArrowExpr) {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n e.type_params.visit_mut_with(&mut folder);\\n\\n let old_hoist = self.hoist;\\n let old = folder.ident_type;\\n folder.ident_type = IdentType::Binding;\\n folder.hoist = false;\\n e.params.visit_mut_with(&mut folder);\\n folder.ident_type = old;\\n folder.hoist = old_hoist;\\n\\n {\\n folder.hoist = false;\\n\\n match &mut e.body {\\n BlockStmtOrExpr::BlockStmt(s) => s.stmts.visit_mut_with(&mut folder),\\n BlockStmtOrExpr::Expr(e) => e.visit_mut_with(&mut folder),\\n }\\n }\\n\\n e.return_type.visit_mut_with(&mut folder);\\n }\\n\\n fn visit_mut_binding_ident(&mut self, i: &mut BindingIdent) {\\n let ident_type = self.ident_type;\\n let in_type = self.in_type;\\n\\n self.in_type = true;\\n self.ident_type = IdentType::Ref;\\n i.type_ann.visit_mut_with(self);\\n\\n self.in_type = false;\\n self.ident_type = ident_type;\\n i.id.visit_mut_with(self);\\n\\n self.in_type = in_type;\\n self.ident_type = ident_type;\\n }\\n\\n fn visit_mut_block_stmt(&mut self, block: &mut BlockStmt) {\\n let child_mark = Mark::fresh(self.mark);\\n\\n let mut child_folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Block, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n block.visit_mut_children_with(&mut child_folder);\\n }\\n\\n /// Handle body of the arrow functions\\n fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {\\n match node {\\n BlockStmtOrExpr::BlockStmt(block) => block.visit_mut_children_with(self).into(),\\n BlockStmtOrExpr::Expr(e) => e.visit_mut_with(self).into(),\\n }\\n }\\n\\n fn visit_mut_catch_clause(&mut self, c: &mut CatchClause) {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n folder.ident_type = IdentType::Binding;\\n c.param.visit_mut_with(&mut folder);\\n folder.ident_type = IdentType::Ref;\\n\\n c.body.visit_mut_children_with(&mut folder);\\n }\\n\\n fn visit_mut_class_decl(&mut self, n: &mut ClassDecl) {\\n self.modify(&mut n.ident, None);\\n\\n // Create a child scope. The class name is only accessible within the class.\\n let child_mark = Mark::fresh(self.mark);\\n\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n folder.ident_type = IdentType::Ref;\\n\\n n.class.visit_mut_with(&mut folder);\\n }\\n\\n fn visit_mut_class_expr(&mut self, n: &mut ClassExpr) {\\n // Create a child scope. The class name is only accessible within the class.\\n let child_mark = Mark::fresh(self.mark);\\n\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n folder.ident_type = IdentType::Binding;\\n n.ident.visit_mut_with(&mut folder);\\n folder.ident_type = IdentType::Ref;\\n\\n n.class.visit_mut_with(&mut folder);\\n }\\n\\n fn visit_mut_class_method(&mut self, m: &mut ClassMethod) {\\n m.key.visit_mut_with(self);\\n\\n {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n m.function.visit_mut_with(&mut child)\\n }\\n }\\n\\n fn visit_mut_class_prop(&mut self, p: &mut ClassProp) {\\n p.decorators.visit_mut_with(self);\\n\\n if p.computed {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n p.key.visit_mut_with(self);\\n self.ident_type = old;\\n }\\n\\n let old = self.ident_type;\\n self.ident_type = IdentType::Ref;\\n p.value.visit_mut_with(self);\\n self.ident_type = old;\\n\\n p.type_ann.visit_mut_with(self);\\n }\\n\\n fn visit_mut_constructor(&mut self, c: &mut Constructor) {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n c.params.visit_mut_with(&mut folder);\\n self.ident_type = old;\\n\\n match &mut c.body {\\n Some(body) => {\\n body.visit_mut_children_with(&mut folder);\\n }\\n None => {}\\n }\\n }\\n\\n fn visit_mut_decl(&mut self, decl: &mut Decl) {\\n self.in_type = false;\\n decl.visit_mut_children_with(self)\\n }\\n\\n fn visit_mut_export_default_decl(&mut self, e: &mut ExportDefaultDecl) {\\n // Treat default exported functions and classes as declarations\\n // even though they are parsed as expressions.\\n match &mut e.decl {\\n DefaultDecl::Fn(f) => {\\n if f.ident.is_some() {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n f.function.visit_mut_with(&mut folder)\\n } else {\\n f.visit_mut_with(self)\\n }\\n }\\n DefaultDecl::Class(c) => {\\n // Skip class expression visitor to treat as a declaration.\\n c.class.visit_mut_with(self)\\n }\\n _ => e.visit_mut_children_with(self),\\n }\\n }\\n\\n fn visit_mut_expr(&mut self, expr: &mut Expr) {\\n self.in_type = false;\\n let old = self.ident_type;\\n self.ident_type = IdentType::Ref;\\n expr.visit_mut_children_with(self);\\n self.ident_type = old;\\n }\\n\\n fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {\\n // We don\\'t fold this as Hoister handles this.\\n\\n {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n node.function.visit_mut_with(&mut folder)\\n }\\n }\\n\\n fn visit_mut_fn_expr(&mut self, e: &mut FnExpr) {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n if let Some(ident) = &mut e.ident {\\n self.in_type = false;\\n folder.modify(ident, None)\\n }\\n e.function.visit_mut_with(&mut folder);\\n }\\n\\n fn visit_mut_for_in_stmt(&mut self, n: &mut ForInStmt) {\\n let child_mark = Mark::fresh(self.mark);\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Block, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n n.left.visit_mut_with(&mut child);\\n n.right.visit_mut_with(&mut child);\\n\\n child.visit_mut_stmt_within_child_scope(&mut *n.body);\\n }\\n\\n fn visit_mut_for_of_stmt(&mut self, n: &mut ForOfStmt) {\\n let child_mark = Mark::fresh(self.mark);\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Block, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n n.left.visit_mut_with(&mut child);\\n n.right.visit_mut_with(&mut child);\\n\\n child.visit_mut_stmt_within_child_scope(&mut *n.body);\\n }\\n\\n fn visit_mut_for_stmt(&mut self, n: &mut ForStmt) {\\n let child_mark = Mark::fresh(self.mark);\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Block, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n self.ident_type = IdentType::Binding;\\n n.init.visit_mut_with(&mut child);\\n self.ident_type = IdentType::Ref;\\n n.test.visit_mut_with(&mut child);\\n self.ident_type = IdentType::Ref;\\n n.update.visit_mut_with(&mut child);\\n\\n child.visit_mut_stmt_within_same_scope(&mut *n.body);\\n }\\n\\n fn visit_mut_function(&mut self, f: &mut Function) {\\n f.type_params.visit_mut_with(self);\\n\\n self.in_type = false;\\n self.ident_type = IdentType::Ref;\\n f.decorators.visit_mut_with(self);\\n\\n self.ident_type = IdentType::Binding;\\n f.params.visit_mut_with(self);\\n\\n f.return_type.visit_mut_with(self);\\n\\n self.ident_type = IdentType::Ref;\\n match &mut f.body {\\n Some(body) => {\\n // Prevent creating new scope.\\n body.visit_mut_children_with(self);\\n }\\n None => {}\\n }\\n }\\n\\n fn visit_mut_ident(&mut self, i: &mut Ident) {\\n match self.ident_type {\\n IdentType::Binding => self.modify(i, None),\\n IdentType::Ref => {\\n let Ident { span, sym, .. } = i;\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\\n \"resolver: IdentRef (type = {}) {}{:?}\",\\n self.in_type,\\n sym,\\n span.ctxt()\\n );\\n }\\n\\n if span.ctxt() != SyntaxContext::empty() {\\n return;\\n }\\n\\n if let Some(mark) = self.mark_for_ref(&sym) {\\n let span = span.apply_mark(mark);\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\t -> {:?}\", span.ctxt());\\n }\\n i.span = span;\\n } else {\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\t -> Unresolved\");\\n }\\n\\n let mark = {\\n let mut mark = self.mark;\\n let mut cur = Some(&self.current);\\n while let Some(scope) = cur {\\n cur = scope.parent;\\n\\n if cur.is_none() {\\n break;\\n }\\n mark = mark.parent();\\n }\\n\\n mark\\n };\\n\\n let span = span.apply_mark(mark);\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\t -> {:?}\", span.ctxt());\\n }\\n\\n i.span = span;\\n // Support hoisting\\n self.modify(i, None)\\n }\\n }\\n // We currently does not touch labels\\n IdentType::Label => {}\\n }\\n }\\n\\n fn visit_mut_import_named_specifier(&mut self, s: &mut ImportNamedSpecifier) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n s.local.visit_mut_with(self);\\n self.ident_type = old;\\n }\\n\\n /// Leftmost one of a member expression should be resolved.\\n fn visit_mut_member_expr(&mut self, e: &mut MemberExpr) {\\n e.obj.visit_mut_with(self);\\n\\n if e.computed {\\n e.prop.visit_mut_with(self);\\n }\\n }\\n\\n // TODO: How should I handle this?\\n typed!(visit_mut_ts_namespace_export_decl, TsNamespaceExportDecl);\\n\\n track_ident_mut!();\\n\\n fn visit_mut_method_prop(&mut self, m: &mut MethodProp) {\\n m.key.visit_mut_with(self);\\n\\n {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n m.function.visit_mut_with(&mut child)\\n };\\n }\\n\\n fn visit_mut_module_items(&mut self, stmts: &mut Vec) {\\n if !self.in_ts_module && self.current.kind != ScopeKind::Fn {\\n return stmts.visit_mut_children_with(self);\\n }\\n\\n // Phase 1: Handle hoisting\\n {\\n let mut hoister = Hoister {\\n resolver: self,\\n kind: None,\\n in_block: false,\\n catch_param_decls: Default::default(),\\n };\\n stmts.visit_mut_children_with(&mut hoister)\\n }\\n\\n // Phase 2.\\n stmts.visit_mut_children_with(self)\\n }\\n\\n fn visit_mut_object_lit(&mut self, o: &mut ObjectLit) {\\n let child_mark = Mark::fresh(self.mark);\\n\\n let mut child_folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Block, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n o.visit_mut_children_with(&mut child_folder);\\n }\\n\\n fn visit_mut_param(&mut self, param: &mut Param) {\\n self.in_type = false;\\n self.ident_type = IdentType::Binding;\\n param.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_pat(&mut self, p: &mut Pat) {\\n self.in_type = false;\\n p.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_private_method(&mut self, m: &mut PrivateMethod) {\\n m.key.visit_mut_with(self);\\n\\n {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n m.function.visit_mut_with(&mut child)\\n }\\n }\\n\\n fn visit_mut_private_name(&mut self, _: &mut PrivateName) {}\\n\\n fn visit_mut_setter_prop(&mut self, n: &mut SetterProp) {\\n n.key.visit_mut_with(self);\\n\\n {\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n\\n child.in_type = false;\\n child.ident_type = IdentType::Binding;\\n n.param.visit_mut_with(&mut child);\\n n.body.visit_mut_with(&mut child);\\n };\\n }\\n\\n fn visit_mut_stmts(&mut self, stmts: &mut Vec) {\\n // Phase 1: Handle hoisting\\n {\\n let mut hoister = Hoister {\\n resolver: self,\\n kind: None,\\n in_block: false,\\n catch_param_decls: Default::default(),\\n };\\n stmts.visit_mut_children_with(&mut hoister)\\n }\\n\\n // Phase 2.\\n stmts.visit_mut_children_with(self)\\n }\\n\\n fn visit_mut_ts_call_signature_decl(&mut self, n: &mut TsCallSignatureDecl) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n n.type_params.visit_mut_with(&mut child);\\n n.params.visit_mut_with(&mut child);\\n n.type_ann.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_construct_signature_decl(&mut self, decl: &mut TsConstructSignatureDecl) {\\n if !self.handle_types {\\n return;\\n }\\n self.in_type = true;\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n // order is important\\n decl.type_params.visit_mut_with(&mut child);\\n decl.params.visit_mut_with(&mut child);\\n decl.type_ann.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_constructor_type(&mut self, ty: &mut TsConstructorType) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n ty.type_params.visit_mut_with(&mut child);\\n ty.params.visit_mut_with(&mut child);\\n ty.type_ann.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_enum_decl(&mut self, decl: &mut TsEnumDecl) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = false;\\n self.modify(&mut decl.id, None);\\n decl.members.visit_mut_with(self);\\n }\\n\\n fn visit_mut_ts_fn_type(&mut self, ty: &mut TsFnType) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n ty.type_params.visit_mut_with(&mut child);\\n ty.params.visit_mut_with(&mut child);\\n ty.type_ann.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_getter_signature(&mut self, n: &mut TsGetterSignature) {\\n if n.computed {\\n n.key.visit_mut_with(self);\\n }\\n\\n n.type_ann.visit_mut_with(self);\\n }\\n\\n fn visit_mut_ts_import_equals_decl(&mut self, n: &mut TsImportEqualsDecl) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = false;\\n self.modify(&mut n.id, None);\\n\\n n.module_ref.visit_mut_with(self);\\n }\\n\\n fn visit_mut_ts_interface_decl(&mut self, n: &mut TsInterfaceDecl) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n self.modify(&mut n.id, None);\\n let child_mark = Mark::fresh(self.mark);\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n n.type_params.visit_mut_with(&mut child);\\n n.extends.visit_mut_with(&mut child);\\n n.body.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_mapped_type(&mut self, n: &mut TsMappedType) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n self.ident_type = IdentType::Binding;\\n n.type_param.visit_mut_with(self);\\n\\n self.in_type = true;\\n self.ident_type = IdentType::Ref;\\n n.name_type.visit_mut_with(self);\\n\\n self.in_type = true;\\n self.ident_type = IdentType::Ref;\\n n.type_ann.visit_mut_with(self);\\n }\\n\\n fn visit_mut_ts_method_signature(&mut self, n: &mut TsMethodSignature) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n let child_mark = Mark::fresh(self.mark);\\n\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n n.type_params.visit_mut_with(&mut child);\\n if n.computed {\\n n.key.visit_mut_with(&mut child);\\n }\\n n.params.visit_mut_with(&mut child);\\n n.type_ann.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_module_decl(&mut self, decl: &mut TsModuleDecl) {\\n match &mut decl.id {\\n TsModuleName::Ident(i) => {\\n self.modify(i, None);\\n }\\n TsModuleName::Str(_) => {}\\n }\\n\\n let child_mark = Mark::fresh(self.mark);\\n\\n let mut child_folder = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Block, Some(&self.current)),\\n self.handle_types,\\n );\\n child_folder.in_ts_module = true;\\n\\n decl.body.visit_mut_children_with(&mut child_folder);\\n }\\n\\n fn visit_mut_ts_namespace_decl(&mut self, n: &mut TsNamespaceDecl) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n self.modify(&mut n.id, None);\\n\\n n.body.visit_mut_with(self);\\n }\\n\\n fn visit_mut_ts_param_prop_param(&mut self, n: &mut TsParamPropParam) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = false;\\n self.ident_type = IdentType::Binding;\\n n.visit_mut_children_with(self)\\n }\\n\\n fn visit_mut_ts_property_signature(&mut self, n: &mut TsPropertySignature) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n if n.computed {\\n n.key.visit_mut_with(self);\\n }\\n let child_mark = Mark::fresh(self.mark);\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n n.type_params.visit_mut_with(&mut child);\\n n.init.visit_mut_with(&mut child);\\n n.params.visit_mut_with(&mut child);\\n n.type_ann.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_qualified_name(&mut self, n: &mut TsQualifiedName) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n self.ident_type = IdentType::Ref;\\n\\n n.left.visit_mut_with(self)\\n }\\n\\n fn visit_mut_ts_setter_signature(&mut self, n: &mut TsSetterSignature) {\\n if n.computed {\\n n.key.visit_mut_with(self);\\n }\\n\\n n.param.visit_mut_with(self);\\n }\\n\\n fn visit_mut_ts_tuple_element(&mut self, e: &mut TsTupleElement) {\\n if !self.handle_types {\\n return;\\n }\\n self.ident_type = IdentType::Ref;\\n e.ty.visit_mut_with(self);\\n }\\n\\n fn visit_mut_ts_type_alias_decl(&mut self, n: &mut TsTypeAliasDecl) {\\n if !self.handle_types {\\n return;\\n }\\n\\n self.in_type = true;\\n self.modify(&mut n.id, None);\\n let child_mark = Mark::fresh(self.mark);\\n // Child folder\\n let mut child = Resolver::new(\\n child_mark,\\n Scope::new(ScopeKind::Fn, Some(&self.current)),\\n self.handle_types,\\n );\\n child.in_type = true;\\n\\n n.type_params.visit_mut_with(&mut child);\\n n.type_ann.visit_mut_with(&mut child);\\n }\\n\\n fn visit_mut_ts_type_param(&mut self, param: &mut TsTypeParam) {\\n if !self.handle_types {\\n return;\\n }\\n self.in_type = true;\\n param.name.visit_mut_with(self);\\n\\n let ident_type = self.ident_type;\\n param.default.visit_mut_with(self);\\n param.constraint.visit_mut_with(self);\\n self.ident_type = ident_type;\\n }\\n\\n fn visit_mut_ts_type_params(&mut self, params: &mut Vec) {\\n for param in params.iter_mut() {\\n self.in_type = true;\\n param.name.visit_mut_with(self);\\n }\\n\\n params.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_var_decl(&mut self, decl: &mut VarDecl) {\\n self.in_type = false;\\n\\n let old_hoist = self.hoist;\\n\\n self.hoist = VarDeclKind::Var == decl.kind;\\n decl.decls.visit_mut_with(self);\\n\\n self.hoist = old_hoist;\\n }\\n\\n fn visit_mut_var_declarator(&mut self, decl: &mut VarDeclarator) {\\n // order is important\\n\\n let old_type = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n decl.name.visit_mut_with(self);\\n self.ident_type = old_type;\\n\\n decl.init.visit_mut_children_with(self);\\n }\\n}\\n\\n/// The folder which handles var / function hoisting.\\nstruct Hoister<\\'a, \\'b> {\\n resolver: &\\'a mut Resolver<\\'b>,\\n kind: Option,\\n /// Hoister should not touch let / const in the block.\\n in_block: bool,\\n catch_param_decls: FxHashSet,\\n}\\n\\nimpl VisitMut for Hoister<\\'_, \\'_> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {\\n if self.catch_param_decls.contains(&node.ident.sym) {\\n return;\\n }\\n\\n self.resolver.in_type = false;\\n self.resolver\\n .modify(&mut node.ident, Some(VarDeclKind::Var));\\n }\\n\\n #[inline]\\n fn visit_mut_expr(&mut self, _: &mut Expr) {}\\n\\n #[inline]\\n fn visit_mut_arrow_expr(&mut self, _: &mut ArrowExpr) {}\\n\\n #[inline]\\n fn visit_mut_tagged_tpl(&mut self, _: &mut TaggedTpl) {}\\n\\n #[inline]\\n fn visit_mut_tpl(&mut self, _: &mut Tpl) {}\\n\\n #[inline]\\n fn visit_mut_function(&mut self, _: &mut Function) {}\\n\\n #[inline]\\n fn visit_mut_setter_prop(&mut self, _: &mut SetterProp) {}\\n\\n fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {\\n if self.in_block {\\n match node.kind {\\n VarDeclKind::Const | VarDeclKind::Let => return,\\n _ => {}\\n }\\n }\\n\\n let old_kind = self.kind;\\n self.kind = Some(node.kind);\\n\\n self.resolver.hoist = false;\\n\\n node.visit_mut_children_with(self);\\n\\n self.kind = old_kind;\\n }\\n\\n #[inline]\\n fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {\\n node.name.visit_mut_with(self);\\n }\\n\\n fn visit_mut_pat(&mut self, node: &mut Pat) {\\n self.resolver.in_type = false;\\n match node {\\n Pat::Ident(i) => {\\n if self.catch_param_decls.contains(&i.id.sym) {\\n return;\\n }\\n\\n self.resolver.modify(&mut i.id, self.kind)\\n }\\n _ => node.visit_mut_children_with(self),\\n }\\n }\\n\\n fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {\\n if self.in_block {\\n return;\\n }\\n self.resolver.in_type = false;\\n self.resolver\\n .modify(&mut node.ident, Some(VarDeclKind::Let));\\n }\\n\\n #[inline]\\n fn visit_mut_catch_clause(&mut self, c: &mut CatchClause) {\\n let params: Vec = find_ids(&c.param);\\n\\n let orig = self.catch_param_decls.clone();\\n\\n self.catch_param_decls\\n .extend(params.into_iter().map(|v| v.0));\\n c.body.visit_mut_with(self);\\n\\n self.catch_param_decls = orig;\\n }\\n\\n #[inline]\\n fn visit_mut_pat_or_expr(&mut self, _: &mut PatOrExpr) {}\\n\\n #[inline]\\n fn visit_mut_param(&mut self, _: &mut Param) {}\\n\\n #[inline]\\n fn visit_mut_constructor(&mut self, _: &mut Constructor) {}\\n\\n fn visit_mut_var_decl_or_expr(&mut self, n: &mut VarDeclOrExpr) {\\n match n {\\n VarDeclOrExpr::VarDecl(VarDecl {\\n kind: VarDeclKind::Let,\\n ..\\n })\\n | VarDeclOrExpr::VarDecl(VarDecl {\\n kind: VarDeclKind::Const,\\n ..\\n }) => {}\\n _ => {\\n n.visit_mut_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_mut_var_decl_or_pat(&mut self, n: &mut VarDeclOrPat) {\\n match n {\\n VarDeclOrPat::VarDecl(VarDecl {\\n kind: VarDeclKind::Let,\\n ..\\n })\\n | VarDeclOrPat::VarDecl(VarDecl {\\n kind: VarDeclKind::Const,\\n ..\\n }) => {}\\n // Hoister should not handle lhs of for in statement below\\n //\\n // const b = [];\\n // {\\n // let a;\\n // for (a in b) {\\n // console.log(a);\\n // }\\n // }\\n VarDeclOrPat::Pat(..) => {}\\n _ => {\\n n.visit_mut_children_with(self);\\n }\\n }\\n }\\n\\n fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt) {\\n let old_in_block = self.in_block;\\n self.in_block = true;\\n n.visit_mut_children_with(self);\\n self.in_block = old_in_block;\\n }\\n\\n fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {\\n // Treat default exported functions and classes as declarations\\n // even though they are parsed as expressions.\\n match &mut node.decl {\\n DefaultDecl::Fn(f) => {\\n if let Some(id) = &mut f.ident {\\n self.resolver.in_type = false;\\n self.resolver.modify(id, Some(VarDeclKind::Var));\\n }\\n\\n f.visit_mut_with(self)\\n }\\n DefaultDecl::Class(c) => {\\n if let Some(id) = &mut c.ident {\\n self.resolver.in_type = false;\\n self.resolver.modify(id, Some(VarDeclKind::Let));\\n }\\n\\n c.visit_mut_with(self)\\n }\\n _ => {\\n node.visit_mut_children_with(self);\\n }\\n }\\n }\\n}\\n',\n", + " 'content_id': '71a39f87d6ebf3630d13e786f534ffb1b303b16e',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 97,\n", + " 'path': '/ecmascript/transforms/base/src/resolver/mod.rs',\n", + " 'size': 42808,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.31523536065431135,\n", + " 'avg_line_length': 41.150366748166256,\n", + " 'blob_id': '6ef4cd2954931d13c5df3ff062293f596b556443',\n", + " 'content': 'use super::util::{\\n self, define_es_module, define_property, has_use_strict, initialize_to_undefined,\\n local_name_for_src, make_descriptor, use_strict, Exports, ModulePass, Scope,\\n};\\nuse crate::path::{ImportResolver, NoopImportResolver};\\nuse anyhow::Context;\\nuse rustc_hash::FxHashSet;\\nuse serde::{Deserialize, Serialize};\\nuse std::{\\n cell::{Ref, RefCell, RefMut},\\n iter,\\n};\\nuse swc_atoms::js_word;\\nuse swc_common::{FileName, Mark, Span, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::helper;\\nuse swc_ecma_utils::{\\n prepend_stmts, private_ident, quote_ident, quote_str, var::VarCollector, DestructuringFinder,\\n ExprFactory,\\n};\\nuse swc_ecma_visit::{noop_fold_type, Fold, FoldWith, VisitWith};\\n\\npub fn amd(config: Config) -> impl Fold {\\n Amd {\\n config,\\n in_top_level: Default::default(),\\n scope: RefCell::new(Default::default()),\\n exports: Default::default(),\\n\\n resolver: None::<(NoopImportResolver, _)>,\\n }\\n}\\n\\npub fn amd_with_resolver(resolver: R, base: FileName, config: Config) -> impl Fold\\nwhere\\n R: ImportResolver,\\n{\\n Amd {\\n config,\\n in_top_level: Default::default(),\\n scope: Default::default(),\\n exports: Default::default(),\\n\\n resolver: Some((resolver, base)),\\n }\\n}\\n\\nstruct Amd\\nwhere\\n R: ImportResolver,\\n{\\n config: Config,\\n in_top_level: bool,\\n scope: RefCell,\\n exports: Exports,\\n\\n resolver: Option<(R, FileName)>,\\n}\\n\\n#[derive(Debug, Clone, Default, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct Config {\\n #[serde(default)]\\n pub module_id: Option,\\n\\n #[serde(flatten, default)]\\n pub config: util::Config,\\n}\\n\\nimpl Fold for Amd\\nwhere\\n R: ImportResolver,\\n{\\n noop_fold_type!();\\n\\n fn fold_expr(&mut self, expr: Expr) -> Expr {\\n let top_level = self.in_top_level;\\n\\n Scope::fold_expr(self, self.exports.0.clone(), top_level, expr)\\n }\\n\\n fn fold_module(&mut self, module: Module) -> Module {\\n let items = module.body;\\n self.in_top_level = true;\\n\\n // Inserted after initializing exported names to undefined.\\n let mut extra_stmts = vec![];\\n let mut stmts = Vec::with_capacity(items.len() + 2);\\n if self.config.config.strict_mode && !has_use_strict(&items) {\\n stmts.push(use_strict());\\n }\\n\\n let mut exports = vec![];\\n let mut initialized = FxHashSet::default();\\n let mut export_alls = vec![];\\n let mut emitted_esmodule = false;\\n let mut has_export = false;\\n let exports_ident = self.exports.0.clone();\\n\\n // Process items\\n for item in items {\\n let decl = match item {\\n ModuleItem::Stmt(stmt) => {\\n extra_stmts.push(stmt.fold_with(self));\\n continue;\\n }\\n ModuleItem::ModuleDecl(decl) => decl,\\n };\\n match decl {\\n ModuleDecl::Import(import) => self.scope.borrow_mut().insert_import(import),\\n\\n ModuleDecl::ExportAll(..)\\n | ModuleDecl::ExportDecl(..)\\n | ModuleDecl::ExportDefaultDecl(..)\\n | ModuleDecl::ExportDefaultExpr(..)\\n | ModuleDecl::ExportNamed(..) => {\\n has_export = true;\\n if !self.config.config.strict && !emitted_esmodule {\\n emitted_esmodule = true;\\n stmts.push(define_es_module(exports_ident.clone()));\\n }\\n\\n macro_rules! init_export {\\n (\"default\") => {{\\n init_export!(js_word!(\"default\"))\\n }};\\n ($name:expr) => {{\\n exports.push($name.clone());\\n initialized.insert($name.clone());\\n }};\\n }\\n match decl {\\n // Function declaration cannot throw an error.\\n ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl: DefaultDecl::Fn(..),\\n ..\\n }) => {\\n // initialized.insert(js_word!(\"default\"));\\n }\\n\\n ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl: DefaultDecl::TsInterfaceDecl(..),\\n ..\\n }) => {}\\n\\n ModuleDecl::ExportAll(ref export) => {\\n self.scope\\n .borrow_mut()\\n .import_types\\n .entry(export.src.value.clone())\\n .and_modify(|v| *v = true);\\n }\\n\\n ModuleDecl::ExportDefaultDecl(..) | ModuleDecl::ExportDefaultExpr(..) => {\\n // TODO: Optimization (when expr cannot throw, `exports.default =\\n // void 0` is not required)\\n init_export!(\"default\")\\n }\\n _ => {}\\n }\\n\\n match decl {\\n ModuleDecl::ExportAll(export) => export_alls.push(export),\\n ModuleDecl::ExportDecl(ExportDecl {\\n decl: decl @ Decl::Class(..),\\n ..\\n })\\n | ModuleDecl::ExportDecl(ExportDecl {\\n decl: decl @ Decl::Fn(..),\\n ..\\n }) => {\\n let (ident, is_class) = match decl {\\n Decl::Class(ref c) => (c.ident.clone(), true),\\n Decl::Fn(ref f) => (f.ident.clone(), false),\\n _ => unreachable!(),\\n };\\n\\n //\\n extra_stmts.push(Stmt::Decl(decl.fold_with(self)));\\n\\n let append_to: &mut Vec<_> = if is_class {\\n &mut extra_stmts\\n } else {\\n // Function declaration cannot throw\\n &mut stmts\\n };\\n\\n append_to.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident.clone().make_member(ident.clone()),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Var(var),\\n ..\\n }) => {\\n extra_stmts.push(Stmt::Decl(Decl::Var(var.clone().fold_with(self))));\\n\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n var.decls.visit_with(\\n &Invalid { span: DUMMY_SP } as _,\\n &mut VarCollector {\\n to: &mut scope.declared_vars,\\n },\\n );\\n\\n let mut found: Vec = vec![];\\n for decl in var.decls {\\n let mut v = DestructuringFinder { found: &mut found };\\n decl.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n\\n for ident in found.drain(..) {\\n scope\\n .exported_vars\\n .entry((ident.sym.clone(), ident.span.ctxt()))\\n .or_default()\\n .push((ident.sym.clone(), ident.span.ctxt()));\\n init_export!(ident.sym);\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident.clone().make_member(ident.clone()),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n }\\n }\\n ModuleDecl::ExportDefaultDecl(decl) => match decl {\\n ExportDefaultDecl {\\n decl: DefaultDecl::Class(ClassExpr { ident, class }),\\n ..\\n } => {\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_default\"));\\n\\n extra_stmts.push(Stmt::Decl(Decl::Class(ClassDecl {\\n ident: ident.clone(),\\n class,\\n declare: false,\\n })));\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident\\n .clone()\\n .make_member(quote_ident!(\"default\")),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n ExportDefaultDecl {\\n decl: DefaultDecl::Fn(FnExpr { ident, function }),\\n ..\\n } => {\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_default\"));\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident\\n .clone()\\n .make_member(quote_ident!(\"default\")),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.clone().into()),\\n }\\n .into_stmt(),\\n );\\n\\n extra_stmts.push(Stmt::Decl(Decl::Fn(\\n FnDecl {\\n ident,\\n function,\\n declare: false,\\n }\\n .fold_with(self),\\n )));\\n }\\n _ => {}\\n },\\n\\n ModuleDecl::ExportDefaultExpr(ExportDefaultExpr { expr, .. }) => {\\n let ident = private_ident!(\"_default\");\\n\\n // We use extra statements because of the initialization\\n extra_stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(ident.clone().into()),\\n init: Some(expr.fold_with(self)),\\n definite: false,\\n }],\\n declare: false,\\n })));\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident.clone().make_member(quote_ident!(\"default\")),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n\\n // export { foo } from \\'foo\\';\\n ModuleDecl::ExportNamed(export) => {\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n let imported = export.src.clone().map(|src| {\\n scope.import_to_export(&src, !export.specifiers.is_empty())\\n });\\n drop(scope);\\n drop(scope_ref_mut);\\n\\n stmts.reserve(export.specifiers.len());\\n\\n for ExportNamedSpecifier { orig, exported, .. } in export\\n .specifiers\\n .into_iter()\\n .map(|e| match e {\\n ExportSpecifier::Named(e) => e,\\n ExportSpecifier::Default(..) => unreachable!(\\n \"export default from \\'foo\\'; should be removed by previous \\\\\\n pass\"\\n ),\\n ExportSpecifier::Namespace(..) => unreachable!(\\n \"export * as Foo from \\'foo\\'; should be removed by \\\\\\n previous pass\"\\n ),\\n })\\n .filter(|e| !e.is_type_only)\\n {\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n let is_import_default = orig.sym == js_word!(\"default\");\\n\\n let key = (orig.sym.clone(), orig.span.ctxt());\\n if scope.declared_vars.contains(&key) {\\n scope.exported_vars.entry(key.clone()).or_default().push(\\n exported\\n .clone()\\n .map(|i| (i.sym.clone(), i.span.ctxt()))\\n .unwrap_or_else(|| {\\n (orig.sym.clone(), orig.span.ctxt())\\n }),\\n );\\n }\\n\\n if let Some(ref src) = export.src {\\n if is_import_default {\\n scope\\n .import_types\\n .entry(src.value.clone())\\n .or_insert(false);\\n }\\n }\\n drop(scope);\\n drop(scope_ref_mut);\\n let value = match imported {\\n Some(ref imported) => Box::new(\\n imported.clone().unwrap().make_member(orig.clone()),\\n ),\\n None => Box::new(Expr::Ident(orig.clone()).fold_with(self)),\\n };\\n\\n // True if we are exporting our own stuff.\\n let is_value_ident = match *value {\\n Expr::Ident(..) => true,\\n _ => false,\\n };\\n\\n if is_value_ident {\\n let exported_symbol = exported\\n .as_ref()\\n .map(|e| e.sym.clone())\\n .unwrap_or_else(|| orig.sym.clone());\\n init_export!(exported_symbol);\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident\\n .clone()\\n .make_member(exported.unwrap_or(orig)),\\n )),\\n op: op!(\"=\"),\\n right: value,\\n }\\n .into_stmt(),\\n );\\n } else {\\n stmts.push(\\n define_property(vec![\\n exports_ident.clone().as_arg(),\\n {\\n // export { foo }\\n // -> \\'foo\\'\\n\\n // export { foo as bar }\\n // -> \\'bar\\'\\n let i = exported.unwrap_or_else(|| orig);\\n Lit::Str(quote_str!(i.span, i.sym)).as_arg()\\n },\\n make_descriptor(value).as_arg(),\\n ])\\n .into_stmt(),\\n );\\n }\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n ModuleDecl::TsImportEquals(..)\\n | ModuleDecl::TsExportAssignment(..)\\n | ModuleDecl::TsNamespaceExport(..) => {}\\n }\\n }\\n\\n // ====================\\n // Handle imports\\n // ====================\\n\\n // Prepended to statements.\\n let mut import_stmts = vec![];\\n let mut define_deps_arg = ArrayLit {\\n span: DUMMY_SP,\\n elems: vec![],\\n };\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n let mut factory_params = Vec::with_capacity(scope.imports.len() + 1);\\n if has_export {\\n define_deps_arg\\n .elems\\n .push(Some(Lit::Str(quote_str!(\"exports\")).as_arg()));\\n factory_params.push(Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(exports_ident.clone().into()),\\n });\\n }\\n\\n // Used only if export * exists\\n let exported_names = {\\n if !export_alls.is_empty() && !exports.is_empty() {\\n let exported_names = private_ident!(\"_exportNames\");\\n stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(exported_names.clone().into()),\\n init: Some(Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: exports\\n .into_iter()\\n .filter_map(|export| {\\n if export == js_word!(\"default\") {\\n return None;\\n }\\n\\n Some(PropOrSpread::Prop(Box::new(Prop::KeyValue(\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(export, DUMMY_SP)),\\n value: Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n },\\n ))))\\n })\\n .collect(),\\n }))),\\n definite: false,\\n }],\\n declare: false,\\n })));\\n\\n Some(exported_names)\\n } else {\\n None\\n }\\n };\\n\\n for export in export_alls {\\n stmts.push(scope.handle_export_all(\\n exports_ident.clone(),\\n exported_names.clone(),\\n export,\\n ));\\n }\\n\\n if !initialized.is_empty() {\\n stmts.push(initialize_to_undefined(exports_ident, initialized).into_stmt());\\n }\\n\\n for (src, import) in scope.imports.drain(..) {\\n let import = import.unwrap_or_else(|| {\\n (\\n local_name_for_src(&src),\\n DUMMY_SP.apply_mark(Mark::fresh(Mark::root())),\\n )\\n });\\n let ident = Ident::new(import.0.clone(), import.1);\\n\\n {\\n let src = match &self.resolver {\\n Some((resolver, base)) => resolver\\n .resolve_import(&base, &src)\\n .with_context(|| format!(\"failed to resolve `{}`\", src))\\n .unwrap(),\\n None => src.clone(),\\n };\\n\\n define_deps_arg\\n .elems\\n .push(Some(Lit::Str(quote_str!(src)).as_arg()));\\n }\\n factory_params.push(Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(ident.clone().into()),\\n });\\n\\n {\\n // handle interop\\n let ty = scope.import_types.get(&src);\\n\\n if let Some(&wildcard) = ty {\\n if !self.config.config.no_interop {\\n let imported = ident.clone();\\n let right = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: if wildcard {\\n helper!(interop_require_wildcard, \"interopRequireWildcard\")\\n } else {\\n helper!(interop_require_default, \"interopRequireDefault\")\\n },\\n args: vec![imported.as_arg()],\\n type_args: Default::default(),\\n }));\\n import_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(ident.clone().into()))),\\n op: op!(\"=\"),\\n right,\\n }\\n .into_stmt(),\\n );\\n }\\n }\\n }\\n }\\n\\n prepend_stmts(&mut stmts, import_stmts.into_iter());\\n stmts.append(&mut extra_stmts);\\n\\n // ====================\\n // Emit\\n // ====================\\n\\n Module {\\n body: vec![CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"define\").as_callee(),\\n args: self\\n .config\\n .module_id\\n .clone()\\n .map(|s| quote_str!(s).as_arg())\\n .into_iter()\\n .chain(iter::once(define_deps_arg.as_arg()))\\n .chain(iter::once(\\n FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n params: factory_params,\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts,\\n }),\\n type_params: Default::default(),\\n return_type: Default::default(),\\n },\\n }\\n .as_arg(),\\n ))\\n .collect(),\\n type_args: Default::default(),\\n }\\n .into_stmt()\\n .into()],\\n ..module\\n }\\n }\\n\\n fn fold_prop(&mut self, p: Prop) -> Prop {\\n match p {\\n Prop::Shorthand(ident) => {\\n let top_level = self.in_top_level;\\n Scope::fold_shorthand_prop(self, top_level, ident)\\n }\\n\\n _ => p.fold_children_with(self),\\n }\\n }\\n\\n ///\\n /// - collects all declared variables for let and var.\\n fn fold_var_decl(&mut self, var: VarDecl) -> VarDecl {\\n if var.kind != VarDeclKind::Const {\\n var.decls.visit_with(\\n &Invalid { span: DUMMY_SP } as _,\\n &mut VarCollector {\\n to: &mut self.scope.borrow_mut().declared_vars,\\n },\\n );\\n }\\n\\n VarDecl {\\n decls: var.decls.fold_with(self),\\n ..var\\n }\\n }\\n\\n mark_as_nested!();\\n}\\n\\nimpl ModulePass for Amd\\nwhere\\n R: ImportResolver,\\n{\\n fn config(&self) -> &util::Config {\\n &self.config.config\\n }\\n\\n fn scope(&self) -> Ref {\\n self.scope.borrow()\\n }\\n\\n fn scope_mut(&mut self) -> RefMut {\\n self.scope.borrow_mut()\\n }\\n\\n fn make_dynamic_import(&mut self, span: Span, args: Vec) -> Expr {\\n handle_dynamic_import(span, args)\\n }\\n}\\n\\n/// ```js\\n/// \\n/// new Promise(function(resolve, reject) {\\n/// require([\\n/// \\'js/foo\\'\\n/// ], function (foo) {\\n/// resolve(foo)\\n/// }, function (err) {\\n// reject(err);\\n/// });\\n/// });\\n///\\n/// ```\\npub(super) fn handle_dynamic_import(span: Span, args: Vec) -> Expr {\\n Expr::New(NewExpr {\\n span,\\n callee: Box::new(Expr::Ident(quote_ident!(\"Promise\"))),\\n args: Some(vec![FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n type_params: Default::default(),\\n return_type: Default::default(),\\n params: vec![\\n // resolve\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"resolve\").into()),\\n },\\n // reject\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"reject\").into()),\\n },\\n ],\\n\\n // require([\\n // \\'js/foo\\'\\n // ], function (foo) {\\n // resolve(foo)\\n // }, function (err) {\\n // reject(err);\\n // });\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![Stmt::Expr(ExprStmt {\\n span: DUMMY_SP,\\n expr: Box::new(\\n CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"require\").as_callee(),\\n args: vec![\\n ArrayLit {\\n span: DUMMY_SP,\\n elems: args.into_iter().map(Some).collect(),\\n }\\n .as_arg(),\\n // function (foo) {\\n // resolve(foo)\\n // }\\n FnExpr {\\n ident: None,\\n\\n function: Function {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n is_async: false,\\n is_generator: false,\\n type_params: Default::default(),\\n return_type: Default::default(),\\n params: vec![Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"dep\").into()),\\n }],\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"resolve\").as_callee(),\\n args: vec![quote_ident!(\"dep\").as_arg()],\\n type_args: Default::default(),\\n }\\n .into_stmt()],\\n }),\\n },\\n }\\n .as_arg(),\\n // function (err) {\\n // reject(err);\\n // };\\n FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n is_async: false,\\n is_generator: false,\\n type_params: Default::default(),\\n return_type: Default::default(),\\n params: vec![Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"err\").into()),\\n }],\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"reject\").as_callee(),\\n args: vec![quote_ident!(\"err\").as_arg()],\\n type_args: Default::default(),\\n }\\n .into_stmt()],\\n }),\\n },\\n }\\n .as_arg(),\\n ],\\n type_args: Default::default(),\\n }\\n .into(),\\n ),\\n })],\\n }),\\n },\\n }\\n .as_arg()]),\\n type_args: Default::default(),\\n })\\n}\\n',\n", + " 'content_id': 'aa729f5db334e4658eff1f008a36c49805d71679',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/transforms/module/src/amd.rs',\n", + " 'size': 34479,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.46269055897298744,\n", + " 'avg_line_length': 27.325757575757574,\n", + " 'blob_id': '616d8e859151ce06c8021bc4b4cbd8cc0658138b',\n", + " 'content': 'use std::hash::BuildHasherDefault;\\n\\nuse super::compat::DATA as CORE_JS_COMPAT_DATA;\\nuse crate::{version::should_enable, Version, Versions};\\nuse indexmap::IndexSet;\\nuse once_cell::sync::Lazy;\\nuse rustc_hash::{FxHashMap, FxHasher};\\nuse swc_atoms::js_word;\\nuse swc_common::DUMMY_SP;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_visit::{Fold, FoldWith};\\n\\nstatic ENTRIES: Lazy>> = Lazy::new(|| {\\n serde_json::from_str::>>(include_str!(\"entries.json\"))\\n .expect(\"failed to parse entries.json from core js 3\")\\n .into_iter()\\n .map(|(k, v)| {\\n (\\n k,\\n v.into_iter()\\n .map(|s: String| &*Box::leak(s.into_boxed_str()))\\n .collect::>(),\\n )\\n })\\n .collect()\\n});\\n\\nstatic MODULES_BY_VERSION: Lazy>> = Lazy::new(|| {\\n serde_json::from_str::>(include_str!(\"modules-by-versions.json\"))\\n .expect(\"failed to parse modules-by-versions.json\")\\n .into_iter()\\n .map(|(k, v): (Version, Vec)| {\\n (\\n k,\\n v.into_iter()\\n .map(|s: String| &*Box::leak(s.into_boxed_str()))\\n .collect::>(),\\n )\\n })\\n .collect()\\n});\\n\\n#[derive(Debug)]\\npub struct Entry {\\n is_any_target: bool,\\n target: Versions,\\n corejs_version: Version,\\n pub imports: IndexSet<&\\'static str, BuildHasherDefault>,\\n remove_regenerator: bool,\\n}\\n\\nimpl Entry {\\n pub fn new(target: Versions, corejs_version: Version, remove_regenerator: bool) -> Self {\\n assert_eq!(corejs_version.major, 3);\\n\\n Entry {\\n is_any_target: target.is_any_target(),\\n target,\\n corejs_version,\\n imports: Default::default(),\\n remove_regenerator,\\n }\\n }\\n\\n /// Add imports.\\n /// Returns true if it\\'s replaced.\\n fn add(&mut self, src: &str) -> bool {\\n let Entry {\\n is_any_target,\\n target,\\n corejs_version,\\n remove_regenerator,\\n ..\\n } = self;\\n\\n if *remove_regenerator && src == \"regenerator-runtime/runtime\" {\\n return true;\\n }\\n\\n if let Some(features) = ENTRIES.get(src) {\\n self.imports.extend(features.iter().filter_map(|f| {\\n let feature = CORE_JS_COMPAT_DATA.get(&**f);\\n\\n if !*is_any_target {\\n if let Some(feature) = feature {\\n if !should_enable(*target, *feature, true) {\\n return None;\\n }\\n }\\n }\\n\\n // println!(\"{} -> {}\", src, f);\\n\\n for (_, features) in MODULES_BY_VERSION\\n .iter()\\n .filter(|(version, _features)| *corejs_version < **version)\\n {\\n if features.contains(&*f) {\\n return None;\\n }\\n }\\n\\n Some(f)\\n }));\\n\\n true\\n } else {\\n false\\n }\\n }\\n}\\n\\nimpl Fold for Entry {\\n fn fold_import_decl(&mut self, i: ImportDecl) -> ImportDecl {\\n let i: ImportDecl = i.fold_children_with(self);\\n\\n let remove = i.specifiers.is_empty() && self.add(&i.src.value);\\n\\n if remove {\\n ImportDecl {\\n src: Str {\\n span: DUMMY_SP,\\n value: js_word!(\"\"),\\n ..i.src\\n },\\n ..i\\n }\\n } else {\\n i\\n }\\n }\\n}\\n',\n", + " 'content_id': 'edb7a2d06240dcdc8448310ae6774e41710b5cfa',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 93,\n", + " 'path': '/ecmascript/preset-env/src/corejs3/entry.rs',\n", + " 'size': 3739,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.40186094403355227,\n", + " 'avg_line_length': 29.326351865955825,\n", + " 'blob_id': '6bc4a0ba1b132382a582f2c9badfab484da0330c',\n", + " 'content': '#![allow(dead_code)]\\n\\nuse self::util::replace_id_with_expr;\\nuse crate::{\\n analyzer::{ProgramData, UsageAnalyzer},\\n compress::util::is_pure_undefined,\\n debug::dump,\\n marks::Marks,\\n mode::Mode,\\n option::CompressOptions,\\n util::{contains_leaping_yield, make_number, MoudleItemExt},\\n};\\nuse retain_mut::RetainMut;\\nuse rustc_hash::FxHashMap;\\nuse std::{fmt::Write, mem::take};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{\\n iter::IdentifyLast, pass::Repeated, util::take::Take, Mark, Spanned, SyntaxContext, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{\\n ident::IdentLike, undefined, ExprExt, ExprFactory, Id, IsEmpty, ModuleItemLike, StmtLike, Type,\\n Value,\\n};\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith, VisitWith};\\nuse tracing::{span, Level};\\nuse Value::Known;\\n\\nmod arguments;\\nmod bools;\\nmod collapse_vars;\\nmod conditionals;\\nmod dead_code;\\nmod evaluate;\\nmod fns;\\nmod hoist_props;\\nmod if_return;\\nmod iife;\\nmod inline;\\nmod join_vars;\\nmod loops;\\nmod ops;\\nmod sequences;\\nmod strings;\\nmod switches;\\nmod unused;\\nmod util;\\n\\n#[derive(Debug, Default)]\\npub(super) struct OptimizerState {\\n vars_for_inlining: FxHashMap>,\\n inlined_vars: FxHashMap>,\\n}\\n\\n/// This pass is simillar to `node.optimize` of terser.\\npub(super) fn optimizer<\\'a, M>(\\n marks: Marks,\\n options: &\\'a CompressOptions,\\n data: &\\'a ProgramData,\\n state: &\\'a mut OptimizerState,\\n mode: &\\'a M,\\n debug_inifinite_loop: bool,\\n) -> impl \\'a + VisitMut + Repeated\\nwhere\\n M: Mode,\\n{\\n assert!(\\n options.top_retain.iter().all(|s| s.trim() != \"\"),\\n \"top_retain should not contain empty string\"\\n );\\n\\n let done = Mark::fresh(Mark::root());\\n let done_ctxt = SyntaxContext::empty().apply_mark(done);\\n Optimizer {\\n marks,\\n changed: false,\\n options,\\n prepend_stmts: Default::default(),\\n append_stmts: Default::default(),\\n lits: Default::default(),\\n state,\\n vars_for_prop_hoisting: Default::default(),\\n simple_props: Default::default(),\\n _simple_array_values: Default::default(),\\n typeofs: Default::default(),\\n data: Some(data),\\n ctx: Default::default(),\\n done,\\n done_ctxt,\\n label: Default::default(),\\n mode,\\n debug_inifinite_loop,\\n }\\n}\\n\\n/// Syntactic context.\\n///\\n/// This should not be modified directly. Use `.with_ctx()` instead.\\n#[derive(Debug, Default, Clone, Copy)]\\nstruct Ctx {\\n /// See [crate::marks::Marks]\\n skip_standalone: bool,\\n\\n /// `true` if the [VarDecl] has const annotation.\\n has_const_ann: bool,\\n\\n in_bool_ctx: bool,\\n\\n in_asm: bool,\\n\\n is_callee: bool,\\n in_call_arg: bool,\\n\\n var_kind: Option,\\n\\n /// `true` if we should not inline values.\\n inline_prevented: bool,\\n /// `true` if we are in the strict mode. This will be set to `true` for\\n /// statements **after** `\\'use strict\\'`\\n in_strict: bool,\\n /// `true` if we are try block. `true` means we cannot be sure about control\\n /// flow.\\n in_try_block: bool,\\n /// `true` while handling `test` of if / while / for.\\n in_cond: bool,\\n\\n /// `true` if we are in `arg` of `delete arg`.\\n is_delete_arg: bool,\\n /// `true` if we are in `arg` of `++arg` or `--arg`.\\n is_update_arg: bool,\\n in_lhs_of_assign: bool,\\n /// `false` for `d` in `d[0] = foo`.\\n is_exact_lhs_of_assign: bool,\\n\\n /// `true` for loop bodies and conditions of loops.\\n executed_multiple_time: bool,\\n\\n /// `true` while handling `expr` of `!expr`\\n in_bang_arg: bool,\\n in_var_decl_of_for_in_or_of_loop: bool,\\n /// `true` while handling inner statements of a labelled statement.\\n stmt_lablled: bool,\\n\\n dont_use_negated_iife: bool,\\n\\n /// `true` while handling top-level export decls.\\n is_exported: bool,\\n\\n /// `true` while handling top level items.\\n top_level: bool,\\n\\n /// `true` while we are in a function or something simillar.\\n in_fn_like: bool,\\n\\n in_block: bool,\\n\\n in_obj_of_non_computed_member: bool,\\n\\n in_tpl_expr: bool,\\n\\n /// True while handling callee, except an arrow expression in callee.\\n is_this_aware_callee: bool,\\n\\n can_inline_arguments: bool,\\n\\n is_nested_if_return_merging: bool,\\n\\n /// Current scope.\\n scope: SyntaxContext,\\n}\\n\\nimpl Ctx {\\n pub fn is_top_level_for_block_level_vars(self) -> bool {\\n if self.top_level {\\n return true;\\n }\\n\\n if self.in_fn_like || self.in_block {\\n return false;\\n }\\n true\\n }\\n\\n pub fn in_top_level(self) -> bool {\\n self.top_level || !self.in_fn_like\\n }\\n}\\n\\nstruct Optimizer<\\'a, M> {\\n marks: Marks,\\n\\n changed: bool,\\n options: &\\'a CompressOptions,\\n\\n /// Statements prepended to the current statement.\\n prepend_stmts: Vec,\\n /// Statements appended to the current statement.\\n append_stmts: Vec,\\n\\n /// Cheap to clone.\\n ///\\n /// Used for inlining.\\n lits: FxHashMap>,\\n\\n state: &\\'a mut OptimizerState,\\n\\n vars_for_prop_hoisting: FxHashMap>,\\n /// Used for `hoist_props`.\\n simple_props: FxHashMap<(Id, JsWord), Box>,\\n _simple_array_values: FxHashMap<(Id, usize), Box>,\\n typeofs: FxHashMap,\\n /// This information is created by analyzing identifier usages.\\n ///\\n /// This is calculated multiple time, but only once per one\\n /// `visit_mut_module`.\\n data: Option<&\\'a ProgramData>,\\n ctx: Ctx,\\n /// In future: This will be used to `mark` node as done.\\n done: Mark,\\n done_ctxt: SyntaxContext,\\n\\n /// Closest label.\\n label: Option,\\n\\n mode: &\\'a M,\\n\\n debug_inifinite_loop: bool,\\n}\\n\\nimpl Repeated for Optimizer<\\'_, M> {\\n fn changed(&self) -> bool {\\n self.changed\\n }\\n\\n fn reset(&mut self) {\\n self.changed = false;\\n }\\n}\\n\\nimpl Optimizer<\\'_, M>\\nwhere\\n M: Mode,\\n{\\n fn handle_stmt_likes(&mut self, stmts: &mut Vec)\\n where\\n T: StmtLike + ModuleItemLike + MoudleItemExt + VisitMutWith,\\n Vec: VisitMutWith + VisitWith,\\n {\\n match self.data {\\n Some(..) => {}\\n None => {\\n unreachable!()\\n }\\n }\\n let mut use_asm = false;\\n let prepend_stmts = self.prepend_stmts.take();\\n let append_stmts = self.append_stmts.take();\\n\\n {\\n let mut child_ctx = Ctx { ..self.ctx };\\n let mut directive_count = 0;\\n\\n if stmts.len() >= 1 {\\n // TODO: Handle multiple directives.\\n match stmts[0].as_stmt() {\\n Some(Stmt::Expr(ExprStmt { expr, .. })) => match &**expr {\\n Expr::Lit(Lit::Str(v)) => {\\n directive_count += 1;\\n\\n if v.value == *\"use strict\" && !v.has_escape {\\n child_ctx.in_strict = true;\\n }\\n\\n if v.value == *\"use asm\" && !v.has_escape {\\n child_ctx.in_asm = true;\\n self.ctx.in_asm = true;\\n use_asm = true;\\n }\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n let mut new = Vec::with_capacity(stmts.len() * 11 / 10);\\n for (i, mut stmt) in stmts.take().into_iter().enumerate() {\\n debug_assert_eq!(self.prepend_stmts, vec![]);\\n debug_assert_eq!(self.append_stmts, vec![]);\\n\\n if i < directive_count {\\n // Don\\'t set in_strict for directive itselfs.\\n stmt.visit_mut_with(self);\\n } else {\\n stmt.visit_mut_with(&mut *self.with_ctx(child_ctx));\\n }\\n\\n new.extend(self.prepend_stmts.drain(..).map(T::from_stmt));\\n new.push(stmt);\\n new.extend(self.append_stmts.drain(..).map(T::from_stmt));\\n }\\n *stmts = new;\\n }\\n\\n self.ctx.in_asm |= use_asm;\\n\\n self.reorder_stmts(stmts);\\n\\n self.merge_sequences_in_stmts(stmts);\\n\\n self.merge_simillar_ifs(stmts);\\n self.join_vars(stmts);\\n\\n self.make_sequences(stmts);\\n\\n self.drop_else_token(stmts);\\n\\n self.break_assignments_in_seqs(stmts);\\n\\n stmts.extend(self.append_stmts.drain(..).map(T::from_stmt));\\n\\n stmts.retain(|stmt| match stmt.as_stmt() {\\n Some(Stmt::Empty(..)) => false,\\n _ => true,\\n });\\n\\n debug_assert_eq!(self.prepend_stmts, vec![]);\\n self.prepend_stmts = prepend_stmts;\\n self.append_stmts = append_stmts;\\n }\\n\\n /// `a = a + 1` => `a += 1`.\\n fn compress_bin_assignment_to_left(&mut self, e: &mut AssignExpr) {\\n // TODO: Handle pure properties.\\n let lhs = match &e.left {\\n PatOrExpr::Expr(e) => match &**e {\\n Expr::Ident(i) => i,\\n _ => return,\\n },\\n PatOrExpr::Pat(p) => match &**p {\\n Pat::Ident(i) => &i.id,\\n _ => return,\\n },\\n };\\n\\n // If left operand of a binary expression is not same as lhs, this method has\\n // nothing to do.\\n let (op, right) = match &mut *e.right {\\n Expr::Bin(BinExpr {\\n left, op, right, ..\\n }) => match &**left {\\n Expr::Ident(r) if lhs.sym == r.sym && lhs.span.ctxt == r.span.ctxt => (op, right),\\n _ => return,\\n },\\n _ => return,\\n };\\n\\n // Don\\'t break code for old browsers.\\n match op {\\n BinaryOp::LogicalOr => return,\\n BinaryOp::LogicalAnd => return,\\n BinaryOp::Exp => return,\\n BinaryOp::NullishCoalescing => return,\\n _ => {}\\n }\\n\\n let op = match op {\\n BinaryOp::In | BinaryOp::InstanceOf => return,\\n\\n BinaryOp::EqEq | BinaryOp::NotEq | BinaryOp::EqEqEq | BinaryOp::NotEqEq => {\\n // TODO(kdy1): Check if this is optimizable.\\n return;\\n }\\n\\n BinaryOp::Lt | BinaryOp::LtEq | BinaryOp::Gt | BinaryOp::GtEq => return,\\n\\n BinaryOp::LShift => op!(\"<<=\"),\\n BinaryOp::RShift => {\\n op!(\">>=\")\\n }\\n BinaryOp::ZeroFillRShift => {\\n op!(\">>>=\")\\n }\\n BinaryOp::Add => {\\n op!(\"+=\")\\n }\\n BinaryOp::Sub => {\\n op!(\"-=\")\\n }\\n BinaryOp::Mul => {\\n op!(\"*=\")\\n }\\n BinaryOp::Div => {\\n op!(\"/=\")\\n }\\n BinaryOp::Mod => {\\n op!(\"%=\")\\n }\\n BinaryOp::BitOr => {\\n op!(\"|=\")\\n }\\n BinaryOp::BitXor => {\\n op!(\"^=\")\\n }\\n BinaryOp::BitAnd => {\\n op!(\"&=\")\\n }\\n BinaryOp::LogicalOr => {\\n op!(\"||=\")\\n }\\n BinaryOp::LogicalAnd => {\\n op!(\"&&=\")\\n }\\n BinaryOp::Exp => {\\n op!(\"**=\")\\n }\\n BinaryOp::NullishCoalescing => {\\n op!(\"??=\")\\n }\\n };\\n\\n e.op = op;\\n e.right = right.take();\\n // Now we can compress it to an assigment\\n }\\n\\n fn compress_array_join(&mut self, e: &mut Expr) {\\n let call = match e {\\n Expr::Call(e) => e,\\n _ => return,\\n };\\n\\n let callee = match &mut call.callee {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(callee) => &mut **callee,\\n };\\n\\n let separator = if call.args.is_empty() {\\n \",\".into()\\n } else if call.args.len() == 1 {\\n if call.args[0].spread.is_some() {\\n return;\\n }\\n\\n if is_pure_undefined(&call.args[0].expr) {\\n \",\".into()\\n } else {\\n match &*call.args[0].expr {\\n Expr::Lit(Lit::Str(s)) => s.value.clone(),\\n Expr::Lit(Lit::Null(..)) => js_word!(\"null\"),\\n _ => return,\\n }\\n }\\n } else {\\n return;\\n };\\n\\n let arr = match callee {\\n Expr::Member(MemberExpr {\\n obj,\\n prop,\\n computed: false,\\n ..\\n }) => match obj {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(obj) => match &mut **obj {\\n Expr::Array(arr) => match &**prop {\\n Expr::Ident(i) if i.sym == *\"join\" => arr,\\n _ => return,\\n },\\n _ => return,\\n },\\n },\\n _ => return,\\n };\\n\\n if arr.elems.iter().any(|elem| match elem {\\n Some(ExprOrSpread {\\n spread: Some(..), ..\\n }) => true,\\n _ => false,\\n }) {\\n return;\\n }\\n\\n let cannot_join_as_str_lit = arr\\n .elems\\n .iter()\\n .filter_map(|v| v.as_ref())\\n .any(|v| match &*v.expr {\\n e if is_pure_undefined(e) => false,\\n Expr::Lit(lit) => match lit {\\n Lit::Str(..) | Lit::Num(..) | Lit::Null(..) => false,\\n _ => true,\\n },\\n _ => true,\\n });\\n\\n if cannot_join_as_str_lit {\\n if !self.options.unsafe_passes {\\n return;\\n }\\n\\n // TODO: Partial join\\n\\n if arr\\n .elems\\n .iter()\\n .filter_map(|v| v.as_ref())\\n .any(|v| match &*v.expr {\\n e if is_pure_undefined(e) => false,\\n Expr::Lit(lit) => match lit {\\n Lit::Str(..) | Lit::Num(..) | Lit::Null(..) => false,\\n _ => true,\\n },\\n // This can change behavior if the value is `undefined` or `null`.\\n Expr::Ident(..) => false,\\n _ => true,\\n })\\n {\\n return;\\n }\\n\\n let sep = Box::new(Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: separator,\\n has_escape: false,\\n kind: Default::default(),\\n })));\\n let mut res = Expr::Lit(Lit::Str(Str {\\n span: DUMMY_SP,\\n value: js_word!(\"\"),\\n has_escape: false,\\n kind: Default::default(),\\n }));\\n\\n fn add(to: &mut Expr, right: Box) {\\n let lhs = to.take();\\n *to = Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(lhs),\\n op: op!(bin, \"+\"),\\n right,\\n });\\n }\\n\\n for (last, elem) in arr.elems.take().into_iter().identify_last() {\\n match elem {\\n Some(ExprOrSpread { spread: None, expr }) => match &*expr {\\n e if is_pure_undefined(e) => {}\\n Expr::Lit(Lit::Null(..)) => {}\\n _ => {\\n add(&mut res, expr);\\n }\\n },\\n _ => {}\\n }\\n\\n if !last {\\n add(&mut res, sep.clone());\\n }\\n }\\n\\n *e = res;\\n\\n return;\\n }\\n\\n let mut res = String::new();\\n for (last, elem) in arr.elems.iter().identify_last() {\\n if let Some(elem) = elem {\\n debug_assert_eq!(elem.spread, None);\\n\\n match &*elem.expr {\\n Expr::Lit(Lit::Str(s)) => {\\n res.push_str(&s.value);\\n }\\n Expr::Lit(Lit::Num(n)) => {\\n write!(res, \"{}\", n.value).unwrap();\\n }\\n e if is_pure_undefined(e) => {}\\n Expr::Lit(Lit::Null(..)) => {}\\n _ => {\\n unreachable!(\\n \"Expression {:#?} cannot be joined and it should be filtered out\",\\n elem.expr\\n )\\n }\\n }\\n }\\n\\n if !last {\\n res.push_str(&separator);\\n }\\n }\\n\\n tracing::debug!(\"Compressing array.join()\");\\n\\n self.changed = true;\\n *e = Expr::Lit(Lit::Str(Str {\\n span: call.span,\\n value: res.into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))\\n }\\n\\n ///\\n /// - `undefined` => `void 0`\\n fn compress_undefined(&mut self, e: &mut Expr) {\\n match e {\\n Expr::Ident(Ident {\\n span,\\n sym: js_word!(\"undefined\"),\\n ..\\n }) => {\\n *e = *undefined(*span);\\n return;\\n }\\n _ => {}\\n }\\n }\\n\\n ///\\n /// - `true` => `!1`\\n /// - `false` => `!0`\\n fn compress_lits(&mut self, e: &mut Expr) {\\n let lit = match e {\\n Expr::Lit(lit) => lit,\\n _ => return,\\n };\\n\\n if self.options.bools_as_ints || self.options.bools {\\n match lit {\\n Lit::Bool(v) => {\\n self.changed = true;\\n tracing::debug!(\"Compressing boolean literal\");\\n *e = Expr::Unary(UnaryExpr {\\n span: v.span,\\n op: op!(\"!\"),\\n arg: Box::new(Expr::Lit(Lit::Num(Number {\\n span: v.span,\\n value: if v.value { 0.0 } else { 1.0 },\\n }))),\\n });\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n fn remove_invalid(&mut self, e: &mut Expr) {\\n match e {\\n Expr::Bin(BinExpr { left, right, .. }) => {\\n self.remove_invalid(left);\\n self.remove_invalid(right);\\n\\n if left.is_invalid() {\\n *e = *right.take();\\n self.remove_invalid(e);\\n return;\\n } else if right.is_invalid() {\\n *e = *left.take();\\n self.remove_invalid(e);\\n return;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n /// Returns [None] if expression is side-effect-free.\\n /// If an expression has a side effect, only side effects are returned.\\n #[cfg_attr(feature = \"debug\", tracing::instrument(skip(self, e)))]\\n fn ignore_return_value(&mut self, e: &mut Expr) -> Option {\\n self.optimize_bang_within_logical_ops(e, true);\\n\\n self.compress_cond_to_logical_ignoring_return_value(e);\\n\\n match e {\\n Expr::Ident(..) | Expr::This(_) | Expr::Invalid(_) | Expr::Lit(..) => {\\n if cfg!(feature = \"debug\") {\\n tracing::debug!(\"ignore_return_value: Dropping unused expr: {}\", dump(&*e));\\n }\\n self.changed = true;\\n return None;\\n }\\n // Function expression cannot have a side effect.\\n Expr::Fn(_) => {\\n tracing::debug!(\\n \"ignore_return_value: Dropping unused fn expr as it does not have any side \\\\\\n effect\"\\n );\\n self.changed = true;\\n return None;\\n }\\n\\n Expr::Class(cls) => {\\n let mut exprs = vec![];\\n exprs.extend(\\n cls.class\\n .super_class\\n .as_mut()\\n .and_then(|e| self.ignore_return_value(e))\\n .map(Box::new),\\n );\\n\\n for member in &mut cls.class.body {\\n match member {\\n ClassMember::Method(ClassMethod { key, .. }) => match key {\\n PropName::Computed(key) => {\\n exprs.extend(self.ignore_return_value(&mut key.expr).map(Box::new));\\n }\\n _ => {}\\n },\\n ClassMember::ClassProp(ClassProp {\\n key,\\n computed,\\n is_static,\\n value,\\n ..\\n }) => {\\n if *computed {\\n exprs.extend(self.ignore_return_value(key).map(Box::new));\\n }\\n\\n if *is_static {\\n if let Some(v) = value {\\n exprs.extend(self.ignore_return_value(v).map(Box::new));\\n }\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n if exprs.is_empty() {\\n return None;\\n }\\n\\n return Some(Expr::Seq(SeqExpr {\\n span: cls.class.span,\\n exprs,\\n }));\\n }\\n\\n Expr::Paren(e) => return self.ignore_return_value(&mut e.expr),\\n\\n Expr::Bin(BinExpr {\\n op: op!(\"&&\") | op!(\"||\"),\\n left,\\n right,\\n ..\\n }) => {\\n let ctx = Ctx {\\n dont_use_negated_iife: self.ctx.dont_use_negated_iife\\n || self.options.side_effects,\\n ..self.ctx\\n };\\n let new_r = self.with_ctx(ctx).ignore_return_value(right);\\n\\n match new_r {\\n Some(r) => {\\n *right = Box::new(r);\\n }\\n None => return self.ignore_return_value(left),\\n }\\n\\n return Some(e.take());\\n }\\n\\n Expr::Unary(UnaryExpr {\\n op: op!(\"delete\"), ..\\n }) => return Some(e.take()),\\n\\n Expr::Unary(UnaryExpr {\\n op: op!(\"void\"), ..\\n }) if !self.options.unused => return Some(e.take()),\\n\\n // We optimize binary expressions if operation is side-effect-free and lhs and rhs is\\n // evaluated regardless of value of lhs.\\n //\\n // Div is exlcuded because of zero.\\n // TOOD: Handle\\n Expr::Bin(BinExpr {\\n op:\\n BinaryOp::EqEq\\n | BinaryOp::NotEq\\n | BinaryOp::EqEqEq\\n | BinaryOp::NotEqEq\\n | BinaryOp::Lt\\n | BinaryOp::LtEq\\n | BinaryOp::Gt\\n | BinaryOp::GtEq\\n | BinaryOp::LShift\\n | BinaryOp::RShift\\n | BinaryOp::ZeroFillRShift\\n | BinaryOp::Add\\n | BinaryOp::Sub\\n | BinaryOp::Mul\\n | BinaryOp::Div\\n | BinaryOp::Mod\\n | BinaryOp::BitOr\\n | BinaryOp::BitXor\\n | BinaryOp::BitAnd\\n | BinaryOp::In\\n | BinaryOp::InstanceOf\\n | BinaryOp::Exp,\\n ..\\n }) => return Some(e.take()),\\n\\n // Pure calls can be removed\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(callee),\\n args,\\n ..\\n }) if match &**callee {\\n Expr::Fn(f) => f\\n .function\\n .body\\n .as_ref()\\n .map(|body| body.stmts.is_empty())\\n .unwrap_or(false),\\n Expr::Arrow(f) => match &f.body {\\n BlockStmtOrExpr::BlockStmt(body) => body.stmts.is_empty(),\\n BlockStmtOrExpr::Expr(_) => false,\\n },\\n _ => false,\\n } && args.is_empty() =>\\n {\\n tracing::debug!(\"ignore_return_value: Dropping a pure call\");\\n self.changed = true;\\n return None;\\n }\\n\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(callee),\\n args,\\n ..\\n }) => {\\n if args.is_empty() {\\n match &mut **callee {\\n Expr::Fn(f) => {\\n if f.function.body.is_none()\\n || f.function.body.as_ref().unwrap().is_empty()\\n {\\n return None;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n return Some(e.take());\\n }\\n\\n Expr::MetaProp(_)\\n | Expr::Await(_)\\n | Expr::New(..)\\n | Expr::Call(..)\\n | Expr::Yield(_)\\n | Expr::Assign(_)\\n | Expr::PrivateName(_)\\n | Expr::Update(_) => return Some(e.take()),\\n\\n // We drop `f.g` in\\n //\\n // function f() {\\n // return f.g, 1\\n // }\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n computed: false,\\n ..\\n }) if self.options.top_level() || !self.ctx.in_top_level() => match &**obj {\\n Expr::Ident(obj) => {\\n if let Some(usage) = self\\n .data\\n .as_ref()\\n .and_then(|data| data.vars.get(&obj.to_id()))\\n {\\n if !usage.declared_as_fn_param && usage.var_kind.is_none() {\\n return None;\\n }\\n\\n if !usage.reassigned && usage.no_side_effect_for_member_access {\\n return None;\\n }\\n }\\n }\\n _ => {}\\n },\\n\\n // TODO: Check if it is a pure property access.\\n Expr::Member(_) => return Some(e.take()),\\n\\n // Not supported. (At least at the moment)\\n Expr::JSXMember(_)\\n | Expr::JSXNamespacedName(_)\\n | Expr::JSXEmpty(_)\\n | Expr::JSXElement(_)\\n | Expr::JSXFragment(_)\\n | Expr::TsTypeAssertion(_)\\n | Expr::TsConstAssertion(_)\\n | Expr::TsNonNull(_)\\n | Expr::TsAs(_) => return Some(e.take()),\\n\\n Expr::Array(arr) => {\\n let mut exprs = vec![];\\n self.changed = true;\\n tracing::debug!(\"ignore_return_value: Inverting an array literal\");\\n for elem in arr.elems.take() {\\n match elem {\\n Some(mut elem) => {\\n exprs.extend(self.ignore_return_value(&mut elem.expr).map(Box::new));\\n }\\n None => {}\\n }\\n }\\n\\n if exprs.is_empty() {\\n return None;\\n }\\n\\n return Some(Expr::Seq(SeqExpr {\\n span: arr.span,\\n exprs,\\n }));\\n }\\n\\n Expr::Object(obj) => {\\n let mut exprs = vec![];\\n self.changed = true;\\n tracing::debug!(\"ignore_return_value: Inverting an object literal\");\\n for prop in obj.props.take() {\\n match prop {\\n PropOrSpread::Spread(mut e) => {\\n exprs.extend(self.ignore_return_value(&mut e.expr).map(Box::new));\\n }\\n PropOrSpread::Prop(prop) => match *prop {\\n Prop::KeyValue(KeyValueProp { key, mut value, .. }) => {\\n match key {\\n PropName::Ident(_) => {}\\n PropName::Str(_) => {}\\n PropName::Num(_) => {}\\n PropName::Computed(mut key) => {\\n exprs.extend(\\n self.ignore_return_value(&mut key.expr).map(Box::new),\\n );\\n }\\n PropName::BigInt(_) => {}\\n }\\n\\n exprs.extend(self.ignore_return_value(&mut value).map(Box::new));\\n }\\n Prop::Getter(GetterProp { key, .. })\\n | Prop::Setter(SetterProp { key, .. })\\n | Prop::Method(MethodProp { key, .. }) => match key {\\n PropName::Ident(_) => {}\\n PropName::Str(_) => {}\\n PropName::Num(_) => {}\\n PropName::Computed(mut key) => {\\n exprs.extend(\\n self.ignore_return_value(&mut key.expr).map(Box::new),\\n );\\n }\\n PropName::BigInt(_) => {}\\n },\\n\\n Prop::Shorthand(_) | Prop::Assign(..) => {}\\n },\\n }\\n }\\n\\n if exprs.is_empty() {\\n return None;\\n }\\n\\n return Some(Expr::Seq(SeqExpr {\\n span: obj.span,\\n exprs,\\n }));\\n }\\n\\n // Preserves negated iife\\n Expr::Unary(UnaryExpr {\\n op: op!(\"!\"), arg, ..\\n }) if (self.options.negate_iife\\n || self.options.reduce_vars\\n || self.options.side_effects)\\n && !self.ctx.dont_use_negated_iife\\n && match &**arg {\\n Expr::Call(arg) => match &arg.callee {\\n ExprOrSuper::Expr(callee) => match &**callee {\\n Expr::Fn(..) => true,\\n _ => false,\\n },\\n _ => false,\\n },\\n _ => false,\\n } =>\\n {\\n tracing::debug!(\"ignore_return_value: Preserving negated iife\");\\n return Some(e.take());\\n }\\n\\n // `delete` is handled above\\n Expr::Unary(expr) => {\\n self.changed = true;\\n tracing::debug!(\"ignore_return_value: Reducing unary ({})\", expr.op);\\n return self.ignore_return_value(&mut expr.arg);\\n }\\n\\n Expr::Bin(BinExpr {\\n span,\\n left,\\n right,\\n op,\\n ..\\n }) => {\\n tracing::debug!(\"ignore_return_value: Reducing binary ({})\", *op);\\n\\n let left = self.ignore_return_value(&mut **left).map(Box::new);\\n let right = self.ignore_return_value(&mut **right).map(Box::new);\\n\\n let mut seq = Expr::Seq(SeqExpr {\\n span: *span,\\n exprs: left.into_iter().chain(right).collect(),\\n });\\n return self.ignore_return_value(&mut seq);\\n }\\n\\n Expr::Cond(cond) => {\\n tracing::trace!(\"ignore_return_value: Cond expr\");\\n\\n self.restore_negated_iife(cond);\\n\\n let ctx = Ctx {\\n dont_use_negated_iife: self.ctx.dont_use_negated_iife\\n || self.options.side_effects,\\n ..self.ctx\\n };\\n\\n let cons_span = cond.cons.span();\\n let alt_span = cond.alt.span();\\n let cons = self\\n .with_ctx(ctx)\\n .ignore_return_value(&mut cond.cons)\\n .map(Box::new);\\n let alt = self\\n .with_ctx(ctx)\\n .ignore_return_value(&mut cond.alt)\\n .map(Box::new);\\n\\n // TODO: Remove if test is side effect free.\\n\\n return Some(Expr::Cond(CondExpr {\\n span: cond.span,\\n test: cond.test.take(),\\n cons: cons.unwrap_or_else(|| {\\n tracing::debug!(\"ignore_return_value: Dropped `cons`\");\\n self.changed = true;\\n undefined(cons_span)\\n }),\\n alt: alt.unwrap_or_else(|| {\\n tracing::debug!(\"ignore_return_value: Dropped `alt`\");\\n self.changed = true;\\n undefined(alt_span)\\n }),\\n }));\\n }\\n\\n Expr::Seq(seq) => {\\n if seq.exprs.is_empty() {\\n return None;\\n }\\n //\\n let mut exprs = seq\\n .exprs\\n .iter_mut()\\n .enumerate()\\n .filter_map(|(idx, expr)| {\\n let is_injected_zero = match &**expr {\\n Expr::Lit(Lit::Num(v)) => v.span.is_dummy(),\\n _ => false,\\n };\\n\\n if idx == 0 && self.ctx.is_this_aware_callee && is_injected_zero {\\n return Some(*expr.take());\\n }\\n let ctx = Ctx {\\n dont_use_negated_iife: idx != 0,\\n ..self.ctx\\n };\\n self.with_ctx(ctx).ignore_return_value(&mut **expr)\\n })\\n .map(Box::new)\\n .collect::>();\\n if exprs.len() <= 1 {\\n return exprs.pop().map(|v| *v);\\n } else {\\n let is_last_undefined = is_pure_undefined(&exprs.last().unwrap());\\n\\n // (foo(), void 0) => void foo()\\n if is_last_undefined {\\n self.changed = true;\\n // Remove `void 0`\\n exprs.pop();\\n\\n // Make return type undefined.\\n if let Some(last) = exprs.last_mut() {\\n tracing::debug!(\"ignore_return_value: Shifting void\");\\n self.changed = true;\\n *last = Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"void\"),\\n arg: last.take(),\\n }));\\n }\\n }\\n\\n if exprs.is_empty() {\\n tracing::debug!(\"ignore_return_value: Dropping empty seq\");\\n return None;\\n }\\n\\n return Some(Expr::Seq(SeqExpr {\\n span: seq.span,\\n exprs,\\n }));\\n }\\n }\\n\\n _ => {}\\n }\\n\\n Some(e.take())\\n }\\n\\n /// `new RegExp(\"([Sap]+)\", \"ig\")` => `/([Sap]+)/gi`\\n fn compress_regexp(&mut self, e: &mut Expr) {\\n let span = e.span();\\n let args = match e {\\n Expr::New(NewExpr { callee, args, .. }) => match &**callee {\\n Expr::Ident(Ident {\\n sym: js_word!(\"RegExp\"),\\n ..\\n }) => args,\\n _ => return,\\n },\\n _ => return,\\n };\\n\\n let args = match args {\\n Some(v) => v,\\n None => return,\\n };\\n if args.is_empty() || args.len() > 2 {\\n return;\\n }\\n\\n // We aborts the method if arguments are not literals.\\n if args.iter().any(|v| {\\n v.spread.is_some()\\n || match &*v.expr {\\n Expr::Lit(Lit::Str(s)) => {\\n if s.value.contains(|c: char| !c.is_ascii()) {\\n return true;\\n }\\n if s.value.contains(\"\\\\\\\\\\\\0\") || s.value.contains(\"/\") {\\n return true;\\n }\\n\\n false\\n }\\n _ => true,\\n }\\n }) {\\n return;\\n }\\n\\n //\\n let pattern = args[0].expr.take();\\n\\n let pattern = match *pattern {\\n Expr::Lit(Lit::Str(s)) => s.value.clone(),\\n _ => {\\n unreachable!()\\n }\\n };\\n\\n let flags = args\\n .get_mut(1)\\n .map(|v| v.expr.take())\\n .map(|v| match *v {\\n Expr::Lit(Lit::Str(s)) => {\\n assert!(s.value.is_ascii());\\n\\n let s = s.value.to_string();\\n let mut bytes = s.into_bytes();\\n bytes.sort();\\n\\n String::from_utf8(bytes).unwrap().into()\\n }\\n _ => {\\n unreachable!()\\n }\\n })\\n .unwrap_or(js_word!(\"\"));\\n\\n tracing::debug!(\"Converting call to RegExp into a regexp literal\");\\n self.changed = true;\\n *e = Expr::Lit(Lit::Regex(Regex {\\n span,\\n exp: pattern,\\n flags,\\n }))\\n }\\n\\n ///\\n /// - `a ? true : false` => `!!a`\\n fn compress_useless_cond_expr(&mut self, expr: &mut Expr) {\\n let cond = match expr {\\n Expr::Cond(c) => c,\\n _ => return,\\n };\\n\\n let lt = cond.cons.get_type();\\n let rt = cond.alt.get_type();\\n match (lt, rt) {\\n (Known(Type::Bool), Known(Type::Bool)) => {}\\n _ => return,\\n }\\n\\n let lb = cond.cons.as_pure_bool();\\n let rb = cond.alt.as_pure_bool();\\n\\n let lb = match lb {\\n Value::Known(v) => v,\\n Value::Unknown => return,\\n };\\n let rb = match rb {\\n Value::Known(v) => v,\\n Value::Unknown => return,\\n };\\n\\n // `cond ? true : false` => !!cond\\n if lb && !rb {\\n self.negate(&mut cond.test);\\n self.negate(&mut cond.test);\\n *expr = *cond.test.take();\\n return;\\n }\\n\\n // `cond ? false : true` => !cond\\n if !lb && rb {\\n self.negate(&mut cond.test);\\n *expr = *cond.test.take();\\n return;\\n }\\n }\\n\\n fn merge_var_decls(&mut self, stmts: &mut Vec) {\\n if !self.options.join_vars && !self.options.hoist_vars {\\n return;\\n }\\n\\n // Merge var declarations fully, if possible.\\n if stmts.windows(2).any(|stmts| match (&stmts[0], &stmts[1]) {\\n (Stmt::Decl(Decl::Var(a)), Stmt::Decl(Decl::Var(b))) => {\\n a.kind == b.kind && !contains_leaping_yield(a) && !contains_leaping_yield(b)\\n }\\n _ => false,\\n }) {\\n self.changed = true;\\n\\n if cfg!(feature = \"debug\") {\\n tracing::debug!(\"Merging variable declarations\");\\n tracing::trace!(\\n \"[Before]: {}\",\\n dump(&BlockStmt {\\n span: DUMMY_SP,\\n stmts: stmts.clone()\\n })\\n )\\n }\\n\\n let orig = take(stmts);\\n let mut new = Vec::with_capacity(orig.len());\\n\\n let mut var_decl: Option = None;\\n\\n for stmt in orig {\\n match stmt {\\n Stmt::Decl(Decl::Var(below)) => {\\n //\\n match var_decl.take() {\\n Some(mut upper) if upper.kind == below.kind => {\\n upper.decls.extend(below.decls);\\n var_decl = Some(upper);\\n }\\n d => {\\n new.extend(d.map(Decl::Var).map(Stmt::Decl));\\n var_decl = Some(below);\\n }\\n }\\n }\\n _ => {\\n // If it\\'s not a var decl,\\n\\n new.extend(var_decl.take().map(Decl::Var).map(Stmt::Decl));\\n new.push(stmt);\\n }\\n }\\n }\\n\\n new.extend(var_decl.take().map(Decl::Var).map(Stmt::Decl));\\n\\n if cfg!(feature = \"debug\") {\\n tracing::trace!(\\n \"[Change] merged: {}\",\\n dump(&BlockStmt {\\n span: DUMMY_SP,\\n stmts: new.clone()\\n })\\n )\\n }\\n *stmts = new\\n }\\n }\\n\\n fn try_removing_block(&mut self, s: &mut Stmt, unwrap_more: bool) {\\n match s {\\n Stmt::Block(bs) => {\\n if bs.stmts.len() == 0 {\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n }\\n\\n // Remove nested blocks\\n if bs.stmts.len() == 1 {\\n if let Stmt::Block(block) = &mut bs.stmts[0] {\\n if block.stmts.iter().all(|stmt| match stmt {\\n Stmt::Decl(..) => false,\\n _ => true,\\n }) {\\n tracing::debug!(\"optimizer: Removing nested block\");\\n self.changed = true;\\n bs.stmts = block.stmts.take();\\n }\\n }\\n }\\n\\n // Unwrap a block with only `var`s.\\n //\\n // TODO: Support multiple statements.\\n if bs.stmts.len() == 1\\n && bs.stmts.iter().all(|stmt| match stmt {\\n Stmt::Decl(Decl::Var(VarDecl {\\n kind: VarDeclKind::Var,\\n ..\\n })) => true,\\n _ => false,\\n })\\n {\\n tracing::debug!(\"optimizer: Unwrapping a block with variable statements\");\\n self.changed = true;\\n *s = bs.stmts[0].take();\\n return;\\n }\\n\\n for stmt in &mut bs.stmts {\\n if let Stmt::Block(block) = &stmt {\\n if block.stmts.is_empty() {\\n self.changed = true;\\n tracing::debug!(\"optimizer: Removing empty block\");\\n *stmt = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n }\\n }\\n }\\n\\n if unwrap_more && bs.stmts.len() == 1 {\\n match &bs.stmts[0] {\\n Stmt::Expr(..) | Stmt::If(..) => {\\n *s = bs.stmts[0].take();\\n tracing::debug!(\"optimizer: Unwrapping block stmt\");\\n self.changed = true;\\n }\\n Stmt::Decl(Decl::Fn(..)) if !self.ctx.in_strict => {\\n *s = bs.stmts[0].take();\\n tracing::debug!(\"optimizer: Unwrapping block stmt in non strcit mode\");\\n self.changed = true;\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n Stmt::If(s) => {\\n self.try_removing_block(&mut s.cons, true);\\n let can_remove_block_of_alt = match &*s.cons {\\n Stmt::Expr(..) | Stmt::If(..) => true,\\n Stmt::Block(bs) if bs.stmts.len() == 1 => match &bs.stmts[0] {\\n Stmt::For(..) => true,\\n _ => false,\\n },\\n _ => false,\\n };\\n if can_remove_block_of_alt {\\n if let Some(alt) = &mut s.alt {\\n self.try_removing_block(alt, true);\\n }\\n }\\n }\\n\\n Stmt::ForIn(s) => {\\n self.try_removing_block(&mut s.body, true);\\n }\\n\\n Stmt::For(s) => {\\n self.try_removing_block(&mut s.body, true);\\n }\\n\\n Stmt::ForOf(s) => {\\n self.try_removing_block(&mut s.body, true);\\n }\\n\\n _ => {}\\n }\\n\\n if !self.options.conditionals\\n && !self.options.sequences()\\n && !self.options.join_vars\\n && !self.options.unused\\n {\\n return;\\n }\\n\\n match s {\\n Stmt::Block(block) if block.stmts.is_empty() => {\\n *s = Stmt::Empty(EmptyStmt { span: block.span });\\n }\\n Stmt::Block(block) if block.stmts.len() == 1 => {\\n *s = block.stmts.take().into_iter().next().unwrap();\\n }\\n _ => {}\\n }\\n }\\n\\n fn compress_if_without_alt(&mut self, s: &mut Stmt) {\\n if !self.options.conditionals {\\n return;\\n }\\n\\n let stmt = match s {\\n Stmt::If(v) => v,\\n _ => return,\\n };\\n\\n if stmt.alt.is_none() {\\n match &mut *stmt.cons {\\n Stmt::Expr(cons) => {\\n self.changed = true;\\n tracing::debug!(\"Converting if statement to a form `test && cons`\");\\n *s = Stmt::Expr(ExprStmt {\\n span: stmt.span,\\n expr: Box::new(stmt.test.take().make_bin(op!(\"&&\"), *cons.expr.take())),\\n });\\n return;\\n }\\n _ => {}\\n }\\n }\\n }\\n}\\n\\nimpl VisitMut for Optimizer<\\'_, M>\\nwhere\\n M: Mode,\\n{\\n noop_visit_mut_type!();\\n\\n fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr) {\\n let ctx = Ctx {\\n can_inline_arguments: true,\\n ..self.ctx\\n };\\n\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_mut_assign_expr(&mut self, e: &mut AssignExpr) {\\n {\\n let ctx = Ctx {\\n in_lhs_of_assign: true,\\n is_exact_lhs_of_assign: true,\\n ..self.ctx\\n };\\n e.left.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n if is_left_access_to_arguments(&e.left) {\\n // self.ctx.can_inline_arguments = false;\\n }\\n }\\n e.right.visit_mut_with(self);\\n\\n self.compress_bin_assignment_to_left(e);\\n self.compress_bin_assignment_to_right(e);\\n }\\n\\n fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp) {\\n n.visit_mut_children_with(self);\\n\\n match &n.value {\\n Some(value) => {\\n if is_pure_undefined(&value) {\\n n.value = None;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_bin_expr(&mut self, n: &mut BinExpr) {\\n {\\n let ctx = Ctx {\\n in_cond: self.ctx.in_cond\\n || match n.op {\\n op!(\"&&\") | op!(\"||\") | op!(\"??\") => true,\\n _ => false,\\n },\\n ..self.ctx\\n };\\n\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n self.compress_typeof_undefined(n);\\n\\n self.optimize_bin_operator(n);\\n\\n self.optimize_bin_and_or(n);\\n\\n if n.op == op!(bin, \"+\") {\\n if let Known(Type::Str) = n.left.get_type() {\\n self.optimize_expr_in_str_ctx(&mut n.right);\\n }\\n\\n if let Known(Type::Str) = n.right.get_type() {\\n self.optimize_expr_in_str_ctx(&mut n.left);\\n }\\n }\\n }\\n\\n fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt) {\\n let ctx = Ctx {\\n stmt_lablled: false,\\n top_level: false,\\n in_block: true,\\n scope: n.span.ctxt,\\n ..self.ctx\\n };\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_mut_call_expr(&mut self, e: &mut CallExpr) {\\n let inline_prevented = self.ctx.inline_prevented || self.has_noinline(e.span);\\n\\n let is_this_undefined = match &e.callee {\\n ExprOrSuper::Super(_) => false,\\n ExprOrSuper::Expr(e) => e.is_ident(),\\n };\\n {\\n let ctx = Ctx {\\n is_callee: true,\\n inline_prevented,\\n is_this_aware_callee: is_this_undefined\\n || match &e.callee {\\n ExprOrSuper::Super(_) => false,\\n ExprOrSuper::Expr(callee) => is_callee_this_aware(&callee),\\n },\\n ..self.ctx\\n };\\n e.callee.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n\\n if is_this_undefined {\\n match &mut e.callee {\\n ExprOrSuper::Expr(callee) => match &mut **callee {\\n Expr::Member(..) => {\\n let zero = Box::new(Expr::Lit(Lit::Num(Number {\\n span: DUMMY_SP,\\n value: 0.0,\\n })));\\n self.changed = true;\\n tracing::debug!(\"injecting zero to preserve `this` in call\");\\n\\n *callee = Box::new(Expr::Seq(SeqExpr {\\n span: callee.span(),\\n exprs: vec![zero, callee.take()],\\n }));\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n {\\n let ctx = Ctx {\\n in_call_arg: true,\\n inline_prevented,\\n is_this_aware_callee: false,\\n ..self.ctx\\n };\\n // TODO: Prevent inline if callee is unknown.\\n e.args.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n\\n self.inline_args_of_iife(e);\\n }\\n\\n fn visit_mut_class(&mut self, n: &mut Class) {\\n n.decorators.visit_mut_with(self);\\n\\n {\\n let ctx = Ctx {\\n inline_prevented: true,\\n ..self.ctx\\n };\\n n.super_class.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n\\n {\\n let ctx = Ctx {\\n in_strict: true,\\n ..self.ctx\\n };\\n n.body.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n }\\n\\n fn visit_mut_class_expr(&mut self, e: &mut ClassExpr) {\\n if !self.options.keep_classnames {\\n self.remove_name_if_not_used(&mut e.ident);\\n }\\n\\n e.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_decl(&mut self, decl: &mut Decl) {\\n decl.visit_mut_children_with(self);\\n\\n self.drop_unused_decl(decl);\\n self.store_typeofs(decl);\\n self.store_decl_for_inlining(decl);\\n }\\n\\n fn visit_mut_default_decl(&mut self, n: &mut DefaultDecl) {\\n match n {\\n DefaultDecl::Class(_) => {}\\n DefaultDecl::Fn(f) => {\\n if !self.options.keep_fargs && self.options.evaluate && self.options.unused {\\n self.drop_unused_params(&mut f.function.params);\\n }\\n }\\n DefaultDecl::TsInterfaceDecl(_) => {}\\n }\\n\\n n.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_export_decl(&mut self, n: &mut ExportDecl) {\\n match &mut n.decl {\\n Decl::Fn(f) => {\\n // I don\\'t know why, but terser removes parameters from an exported function if\\n // `unused` is true, regardless of keep_fargs or others.\\n if self.options.unused {\\n self.drop_unused_params(&mut f.function.params);\\n }\\n }\\n _ => {}\\n }\\n\\n let ctx = Ctx {\\n is_exported: true,\\n ..self.ctx\\n };\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_mut_export_default_decl(&mut self, n: &mut ExportDefaultDecl) {\\n let ctx = Ctx {\\n is_exported: true,\\n ..self.ctx\\n };\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n let ctx = Ctx {\\n is_exported: false,\\n ..self.ctx\\n };\\n e.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n\\n match e {\\n Expr::Seq(seq) if seq.exprs.len() == 1 => {\\n *e = *seq.exprs[0].take();\\n }\\n\\n _ => {}\\n }\\n\\n self.remove_invalid(e);\\n\\n self.optimize_str_access_to_arguments(e);\\n\\n self.replace_props(e);\\n\\n self.drop_unused_assignments(e);\\n\\n self.compress_regexp(e);\\n\\n self.compress_lits(e);\\n\\n self.compress_typeofs(e);\\n\\n self.optimize_nullish_coalescing(e);\\n\\n self.compress_logical_exprs_as_bang_bang(e, false);\\n\\n self.compress_useless_cond_expr(e);\\n\\n self.inline(e);\\n\\n match e {\\n Expr::Bin(bin) => {\\n let expr = self.optimize_lit_cmp(bin);\\n if let Some(expr) = expr {\\n tracing::debug!(\"Optimizing: Literal comparison\");\\n self.changed = true;\\n *e = expr;\\n }\\n }\\n _ => {}\\n }\\n\\n self.compress_cond_expr_if_simillar(e);\\n\\n self.compress_negated_bin_eq(e);\\n self.compress_array_join(e);\\n\\n if self.options.negate_iife {\\n self.negate_iife_in_cond(e);\\n }\\n\\n self.collapse_assignment_to_vars(e);\\n\\n self.evaluate(e);\\n\\n self.invoke_iife(e);\\n\\n self.optimize_bangbang(e);\\n\\n match e {\\n Expr::Seq(s) if s.exprs.is_empty() => {\\n e.take();\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_expr_stmt(&mut self, n: &mut ExprStmt) {\\n n.visit_mut_children_with(self);\\n\\n let mut need_ignore_return_value = false;\\n\\n // If negate_iife is true, it\\'s already handled by\\n // visit_mut_children_with(self) above.\\n if !self.options.negate_iife {\\n // I(kdy1) don\\'t know why this check if required, but there are two test cases\\n // with `options.expressions` as only difference.\\n if !self.options.expr {\\n need_ignore_return_value |= self.negate_iife_in_cond(&mut n.expr);\\n }\\n }\\n\\n self.negate_iife_ignoring_ret(&mut n.expr);\\n\\n let is_directive = match &*n.expr {\\n Expr::Lit(Lit::Str(..)) => true,\\n _ => false,\\n };\\n\\n if is_directive {\\n return;\\n }\\n\\n if need_ignore_return_value\\n || self.options.unused\\n || self.options.side_effects\\n || (self.options.sequences() && n.expr.is_seq())\\n || (self.options.conditionals\\n && match &*n.expr {\\n Expr::Bin(BinExpr {\\n op: op!(\"||\") | op!(\"&&\"),\\n ..\\n }) => true,\\n _ => false,\\n })\\n {\\n // Preserve top-level negated iifes.\\n match &*n.expr {\\n Expr::Unary(unary) => match &*unary.arg {\\n Expr::Call(CallExpr {\\n callee: ExprOrSuper::Expr(callee),\\n ..\\n }) => match &**callee {\\n Expr::Fn(..) => return,\\n _ => {}\\n },\\n\\n _ => {}\\n },\\n _ => {}\\n }\\n let expr = self.ignore_return_value(&mut n.expr);\\n n.expr = expr.map(Box::new).unwrap_or_else(|| {\\n if cfg!(feature = \"debug\") {\\n tracing::debug!(\"visit_mut_expr_stmt: Dropped an expression statement\");\\n }\\n undefined(DUMMY_SP)\\n });\\n } else {\\n match &mut *n.expr {\\n Expr::Seq(e) => {\\n // Non-last items are handled by visit_mut_seq_expr\\n if let Some(e) = e.exprs.last_mut() {\\n self.optimize_bang_within_logical_ops(e, true);\\n }\\n }\\n _ => {\\n self.optimize_bang_within_logical_ops(&mut *n.expr, true);\\n }\\n }\\n }\\n }\\n\\n fn visit_mut_fn_decl(&mut self, f: &mut FnDecl) {\\n if !self.options.keep_fargs && self.options.evaluate && self.options.unused {\\n self.drop_unused_params(&mut f.function.params);\\n }\\n\\n f.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_fn_expr(&mut self, e: &mut FnExpr) {\\n if !self.options.keep_fnames {\\n self.remove_name_if_not_used(&mut e.ident);\\n }\\n\\n e.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_for_in_stmt(&mut self, n: &mut ForInStmt) {\\n n.right.visit_mut_with(self);\\n\\n let ctx = Ctx {\\n in_var_decl_of_for_in_or_of_loop: true,\\n ..self.ctx\\n };\\n n.left.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n n.body.visit_mut_with(self);\\n }\\n\\n fn visit_mut_for_of_stmt(&mut self, n: &mut ForOfStmt) {\\n n.right.visit_mut_with(self);\\n\\n let ctx = Ctx {\\n in_var_decl_of_for_in_or_of_loop: true,\\n ..self.ctx\\n };\\n n.left.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n n.body.visit_mut_with(self);\\n }\\n\\n fn visit_mut_for_stmt(&mut self, s: &mut ForStmt) {\\n let ctx = Ctx {\\n executed_multiple_time: true,\\n ..self.ctx\\n };\\n\\n s.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n\\n self.with_ctx(ctx).optimize_init_of_for_stmt(s);\\n\\n self.with_ctx(ctx).drop_if_break(s);\\n }\\n\\n fn visit_mut_function(&mut self, n: &mut Function) {\\n {\\n let ctx = Ctx {\\n stmt_lablled: false,\\n ..self.ctx\\n };\\n n.decorators.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n\\n let is_standalone = n.span.has_mark(self.marks.standalone);\\n\\n // We don\\'t dig into standalone function, as it does not share any variable with\\n // outer scope.\\n if self.ctx.skip_standalone && is_standalone {\\n return;\\n }\\n\\n let old_in_asm = self.ctx.in_asm;\\n\\n {\\n let ctx = Ctx {\\n skip_standalone: self.ctx.skip_standalone || is_standalone,\\n stmt_lablled: false,\\n in_fn_like: true,\\n scope: n.span.ctxt,\\n can_inline_arguments: true,\\n ..self.ctx\\n };\\n let optimizer = &mut *self.with_ctx(ctx);\\n\\n n.params.visit_mut_with(optimizer);\\n match n.body.as_mut() {\\n Some(body) => {\\n // Bypass block scope handler.\\n body.visit_mut_children_with(optimizer);\\n }\\n None => {}\\n }\\n }\\n\\n if let Some(body) = &mut n.body {\\n self.merge_if_returns(&mut body.stmts, false, true);\\n self.drop_else_token(&mut body.stmts);\\n }\\n\\n {\\n let ctx = Ctx {\\n can_inline_arguments: true,\\n ..self.ctx\\n };\\n self.with_ctx(ctx).optimize_usage_of_arguments(n);\\n }\\n\\n self.ctx.in_asm = old_in_asm;\\n }\\n\\n fn visit_mut_if_stmt(&mut self, n: &mut IfStmt) {\\n n.test.visit_mut_with(self);\\n\\n let ctx = Ctx {\\n in_cond: true,\\n ..self.ctx\\n };\\n\\n n.cons.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n n.alt.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n self.negate_if_stmt(n);\\n\\n self.merge_nested_if(n);\\n\\n self.merge_else_if(n);\\n }\\n\\n fn visit_mut_labeled_stmt(&mut self, n: &mut LabeledStmt) {\\n let ctx = Ctx {\\n stmt_lablled: true,\\n ..self.ctx\\n };\\n let old_label = self.label.take();\\n self.label = Some(n.label.to_id());\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n self.label = old_label;\\n }\\n\\n fn visit_mut_member_expr(&mut self, n: &mut MemberExpr) {\\n {\\n let ctx = Ctx {\\n in_obj_of_non_computed_member: !n.computed,\\n is_exact_lhs_of_assign: false,\\n ..self.ctx\\n };\\n n.obj.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n if n.computed {\\n let ctx = Ctx {\\n is_exact_lhs_of_assign: false,\\n ..self.ctx\\n };\\n n.prop.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n }\\n\\n fn visit_mut_module_items(&mut self, stmts: &mut Vec) {\\n let ctx = Ctx {\\n top_level: true,\\n skip_standalone: true,\\n ..self.ctx\\n };\\n self.with_ctx(ctx).handle_stmt_likes(stmts);\\n\\n for (from, to) in self.state.inlined_vars.drain() {\\n tracing::debug!(\"inline: Inlining `{}{:?}`\", from.0, from.1);\\n replace_id_with_expr(stmts, from, to);\\n }\\n\\n stmts.retain(|s| match s {\\n ModuleItem::Stmt(Stmt::Empty(..)) => false,\\n _ => true,\\n });\\n }\\n\\n fn visit_mut_new_expr(&mut self, n: &mut NewExpr) {\\n {\\n let ctx = Ctx {\\n is_callee: true,\\n ..self.ctx\\n };\\n n.callee.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n\\n {\\n let ctx = Ctx {\\n in_call_arg: true,\\n ..self.ctx\\n };\\n n.args.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n }\\n\\n fn visit_mut_opt_stmt(&mut self, s: &mut Option>) {\\n s.visit_mut_children_with(self);\\n\\n match s.as_deref() {\\n Some(Stmt::Empty(..)) => {\\n self.changed = true;\\n tracing::debug!(\"misc: Removing empty statement\");\\n *s = None;\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_opt_var_decl_or_expr(&mut self, n: &mut Option) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n Some(VarDeclOrExpr::Expr(e)) => match &mut **e {\\n Expr::Seq(SeqExpr { exprs, .. }) if exprs.is_empty() => {\\n *n = None;\\n return;\\n }\\n _ => {}\\n },\\n Some(VarDeclOrExpr::VarDecl(v)) => {\\n if v.decls.is_empty() {\\n *n = None;\\n return;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_param(&mut self, n: &mut Param) {\\n n.visit_mut_children_with(self);\\n\\n self.drop_unused_param(&mut n.pat);\\n }\\n\\n fn visit_mut_params(&mut self, n: &mut Vec) {\\n n.visit_mut_children_with(self);\\n\\n n.retain(|p| !p.pat.is_invalid());\\n }\\n\\n fn visit_mut_prop(&mut self, n: &mut Prop) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n Prop::Shorthand(i) => {\\n if self.lits.contains_key(&i.to_id())\\n || self.state.vars_for_inlining.contains_key(&i.to_id())\\n {\\n let mut e = Box::new(Expr::Ident(i.clone()));\\n e.visit_mut_with(self);\\n\\n *n = Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(i.clone()),\\n value: e,\\n });\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_return_stmt(&mut self, n: &mut ReturnStmt) {\\n n.visit_mut_children_with(self);\\n\\n if let Some(arg) = &mut n.arg {\\n self.optimize_in_fn_termiation(&mut **arg);\\n }\\n }\\n\\n #[cfg_attr(feature = \"debug\", tracing::instrument(skip(self, n)))]\\n fn visit_mut_seq_expr(&mut self, n: &mut SeqExpr) {\\n {\\n let ctx = Ctx {\\n dont_use_negated_iife: true,\\n ..self.ctx\\n };\\n\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n self.shift_void(n);\\n\\n self.shift_assignment(n);\\n\\n {\\n let should_preserve_zero = match n.exprs.last().map(|v| &**v) {\\n Some(Expr::Member(..)) => true,\\n Some(Expr::Ident(Ident {\\n sym: js_word!(\"eval\"),\\n ..\\n })) => true,\\n _ => false,\\n };\\n\\n let exprs = n\\n .exprs\\n .iter_mut()\\n .enumerate()\\n .identify_last()\\n .filter_map(|(last, (idx, expr))| {\\n let is_injected_zero = match &**expr {\\n Expr::Lit(Lit::Num(v)) => v.span.is_dummy(),\\n _ => false,\\n };\\n\\n let can_remove = !last\\n && (idx != 0\\n || !is_injected_zero\\n || !self.ctx.is_this_aware_callee\\n || !should_preserve_zero);\\n\\n let ret = if can_remove {\\n // If negate_iife is true, it\\'s already handled by\\n // visit_mut_children_with(self) above.\\n if !self.options.negate_iife {\\n self.negate_iife_in_cond(&mut **expr);\\n }\\n\\n self.ignore_return_value(&mut **expr).map(Box::new)\\n } else {\\n Some(expr.take())\\n };\\n\\n ret\\n })\\n .collect::>();\\n n.exprs = exprs;\\n }\\n\\n self.merge_sequences_in_seq_expr(n);\\n\\n self.lift_seqs_of_assign(n);\\n }\\n\\n fn visit_mut_stmt(&mut self, s: &mut Stmt) {\\n let _tracing = if cfg!(feature = \"debug\") && self.debug_inifinite_loop {\\n let text = dump(&*s);\\n\\n if text.lines().count() < 10 {\\n Some(span!(Level::ERROR, \"visit_mut_stmt\", \"start\" = &*text).entered())\\n } else {\\n None\\n }\\n } else {\\n None\\n };\\n\\n let ctx = Ctx {\\n is_callee: false,\\n is_delete_arg: false,\\n is_update_arg: false,\\n in_lhs_of_assign: false,\\n in_bang_arg: false,\\n is_exported: false,\\n in_obj_of_non_computed_member: false,\\n ..self.ctx\\n };\\n s.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n\\n if cfg!(feature = \"debug\") && self.debug_inifinite_loop {\\n let text = dump(&*s);\\n\\n if text.lines().count() < 10 {\\n tracing::debug!(\"after: visit_mut_children_with: {}\", text);\\n }\\n }\\n\\n match s {\\n Stmt::Expr(ExprStmt { expr, .. }) => {\\n if is_pure_undefined(expr) {\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n }\\n\\n let is_directive = match &**expr {\\n Expr::Lit(Lit::Str(..)) => true,\\n _ => false,\\n };\\n\\n if self.options.directives && is_directive {\\n if self.ctx.in_strict\\n && match &**expr {\\n Expr::Lit(Lit::Str(Str { value, .. })) => *value == *\"use strict\",\\n _ => false,\\n }\\n {\\n tracing::debug!(\"Removing \\'use strict\\'\");\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n }\\n }\\n\\n if self.options.unused {\\n let can_be_removed = !is_directive && !expr.may_have_side_effects();\\n\\n if can_be_removed {\\n self.changed = true;\\n tracing::debug!(\"unused: Dropping an expression without side effect\");\\n if cfg!(feature = \"debug\") {\\n tracing::trace!(\"unused: [Change] Dropping \\\\n{}\\\\n\", dump(&*expr));\\n }\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n }\\n }\\n }\\n _ => {}\\n }\\n\\n self.optiimze_loops_if_cond_is_false(s);\\n self.optimize_loops_with_break(s);\\n\\n match s {\\n // We use var devl with no declarator to indicate we dropped an decl.\\n Stmt::Decl(Decl::Var(VarDecl { decls, .. })) if decls.is_empty() => {\\n *s = Stmt::Empty(EmptyStmt { span: DUMMY_SP });\\n return;\\n }\\n _ => {}\\n }\\n\\n self.try_removing_block(s, false);\\n\\n self.extract_vars_in_subscopes(s);\\n\\n self.compress_if_without_alt(s);\\n\\n self.compress_if_stmt_as_cond(s);\\n\\n self.compress_if_stmt_as_expr(s);\\n\\n self.optimize_const_switches(s);\\n\\n self.optimize_switches(s);\\n\\n if cfg!(feature = \"debug\") && self.debug_inifinite_loop {\\n let text = dump(&*s);\\n\\n if text.lines().count() < 10 {\\n tracing::debug!(\"after: visit_mut_stmt: {}\", text);\\n }\\n }\\n }\\n\\n fn visit_mut_stmts(&mut self, stmts: &mut Vec) {\\n let ctx = Ctx {\\n top_level: false,\\n ..self.ctx\\n };\\n\\n self.with_ctx(ctx).inject_else(stmts);\\n\\n self.with_ctx(ctx).handle_stmt_likes(stmts);\\n\\n self.with_ctx(ctx).merge_var_decls(stmts);\\n\\n stmts.retain(|s| match s {\\n Stmt::Empty(..) => false,\\n _ => true,\\n });\\n\\n if stmts.len() == 1 {\\n match &stmts[0] {\\n Stmt::Expr(ExprStmt { expr, .. }) => match &**expr {\\n Expr::Lit(Lit::Str(s)) => {\\n if s.value == *\"use strict\" {\\n stmts.clear();\\n }\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_mut_str(&mut self, s: &mut Str) {\\n s.visit_mut_children_with(self);\\n\\n s.kind = Default::default()\\n }\\n\\n fn visit_mut_switch_cases(&mut self, n: &mut Vec) {\\n n.visit_mut_children_with(self);\\n\\n self.optimize_switch_cases(n);\\n }\\n\\n fn visit_mut_switch_stmt(&mut self, n: &mut SwitchStmt) {\\n let ctx = Ctx {\\n inline_prevented: !self.options.switches,\\n ..self.ctx\\n };\\n n.discriminant.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n self.drop_unreachable_cases(n);\\n\\n n.cases.visit_mut_with(self);\\n }\\n\\n /// We don\\'t optimize [Tpl] contained in [TaggedTpl].\\n fn visit_mut_tagged_tpl(&mut self, n: &mut TaggedTpl) {\\n n.tag.visit_mut_with(self);\\n }\\n\\n fn visit_mut_throw_stmt(&mut self, n: &mut ThrowStmt) {\\n n.visit_mut_children_with(self);\\n\\n self.optimize_in_fn_termiation(&mut n.arg);\\n }\\n\\n fn visit_mut_tpl(&mut self, n: &mut Tpl) {\\n debug_assert_eq!(n.exprs.len() + 1, n.quasis.len());\\n\\n {\\n let ctx = Ctx {\\n in_tpl_expr: true,\\n ..self.ctx\\n };\\n let mut o = self.with_ctx(ctx);\\n n.visit_mut_children_with(&mut *o);\\n }\\n\\n n.exprs\\n .iter_mut()\\n .for_each(|expr| self.optimize_expr_in_str_ctx(&mut **expr));\\n }\\n\\n fn visit_mut_try_stmt(&mut self, n: &mut TryStmt) {\\n let ctx = Ctx {\\n in_try_block: true,\\n ..self.ctx\\n };\\n n.block.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n n.handler.visit_mut_with(self);\\n\\n n.finalizer.visit_mut_with(self);\\n }\\n\\n fn visit_mut_unary_expr(&mut self, n: &mut UnaryExpr) {\\n let ctx = Ctx {\\n in_bang_arg: n.op == op!(\"!\"),\\n is_delete_arg: n.op == op!(\"delete\"),\\n ..self.ctx\\n };\\n\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n\\n // infinite loop\\n match n.op {\\n op!(\"void\") => match &*n.arg {\\n Expr::Lit(Lit::Num(..)) => {}\\n\\n _ => {\\n let arg = self.ignore_return_value(&mut n.arg);\\n\\n n.arg = Box::new(arg.unwrap_or_else(|| make_number(DUMMY_SP, 0.0)));\\n }\\n },\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr) {\\n let ctx = Ctx {\\n is_update_arg: true,\\n ..self.ctx\\n };\\n\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n fn visit_mut_var_decl(&mut self, n: &mut VarDecl) {\\n {\\n let ctx = Ctx {\\n is_update_arg: false,\\n has_const_ann: self.has_const_ann(n.span),\\n var_kind: Some(n.kind),\\n ..self.ctx\\n };\\n\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n\\n if n.kind == VarDeclKind::Let {\\n n.decls.iter_mut().for_each(|var| {\\n if let Some(e) = &var.init {\\n if is_pure_undefined(e) {\\n self.changed = true;\\n tracing::debug!(\\n \"Dropping explicit initializer which evaluates to `undefined`\"\\n );\\n\\n var.init = None;\\n }\\n }\\n });\\n }\\n }\\n\\n fn visit_mut_var_declarator(&mut self, var: &mut VarDeclarator) {\\n {\\n let prevent_inline = match &var.name {\\n Pat::Ident(BindingIdent {\\n id:\\n Ident {\\n sym: js_word!(\"arguments\"),\\n ..\\n },\\n ..\\n }) => true,\\n _ => false,\\n };\\n\\n let ctx = Ctx {\\n inline_prevented: self.ctx.inline_prevented || prevent_inline,\\n ..self.ctx\\n };\\n\\n var.name.visit_mut_with(&mut *self.with_ctx(ctx));\\n\\n var.init.visit_mut_with(&mut *self.with_ctx(ctx));\\n }\\n\\n self.remove_duplicate_names(var);\\n\\n self.store_var_for_inining(var);\\n self.store_var_for_prop_hoisting(var);\\n }\\n\\n fn visit_mut_var_declarators(&mut self, vars: &mut Vec) {\\n vars.retain_mut(|var| {\\n let had_init = var.init.is_some();\\n\\n if var.name.is_invalid() {\\n self.changed = true;\\n return false;\\n }\\n\\n var.visit_mut_with(self);\\n\\n if var.name.is_invalid() {\\n // It will be inlined.\\n self.changed = true;\\n return false;\\n }\\n\\n // It will be inlined.\\n if had_init && var.init.is_none() {\\n self.changed = true;\\n return false;\\n }\\n\\n true\\n });\\n\\n for idx in 0..vars.len() {\\n let v = &mut vars[idx];\\n if v.init\\n .as_deref()\\n .map(|e| !e.may_have_side_effects())\\n .unwrap_or(true)\\n {\\n self.drop_unused_var_declarator(v, true);\\n }\\n }\\n\\n for idx in 0..vars.len() {\\n let v = &mut vars[idx];\\n self.drop_unused_var_declarator(v, true);\\n if v.name.is_invalid() {\\n continue;\\n }\\n\\n break;\\n }\\n\\n for idx in (0..vars.len()).rev() {\\n let v = &mut vars[idx];\\n self.drop_unused_var_declarator(v, false);\\n if v.name.is_invalid() {\\n continue;\\n }\\n\\n break;\\n }\\n\\n vars.retain(|var| {\\n if var.name.is_invalid() {\\n self.changed = true;\\n return false;\\n }\\n\\n if let Some(Expr::Invalid(..)) = var.init.as_deref() {\\n return false;\\n }\\n\\n true\\n });\\n }\\n\\n fn visit_mut_while_stmt(&mut self, n: &mut WhileStmt) {\\n {\\n let ctx = Ctx {\\n executed_multiple_time: true,\\n ..self.ctx\\n };\\n n.visit_mut_children_with(&mut *self.with_ctx(ctx));\\n }\\n }\\n\\n fn visit_mut_yield_expr(&mut self, n: &mut YieldExpr) {\\n n.visit_mut_children_with(self);\\n\\n if let Some(arg) = &mut n.arg {\\n self.compress_undefined(&mut **arg);\\n\\n if !n.delegate {\\n if is_pure_undefined(&arg) {\\n n.arg = None;\\n }\\n }\\n }\\n }\\n}\\n\\n/// If true, `0` in `(0, foo.bar)()` is preserved.\\nfn is_callee_this_aware(callee: &Expr) -> bool {\\n match &*callee {\\n Expr::Arrow(..) => return false,\\n Expr::Seq(..) => return true,\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n ..\\n }) => match &**obj {\\n Expr::Ident(obj) => {\\n if &*obj.sym == \"consoole\" {\\n return false;\\n }\\n }\\n _ => {}\\n },\\n\\n _ => {}\\n }\\n\\n true\\n}\\n\\nfn is_expr_access_to_arguments(l: &Expr) -> bool {\\n match l {\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n ..\\n }) => match &**obj {\\n Expr::Ident(Ident {\\n sym: js_word!(\"arguments\"),\\n ..\\n }) => true,\\n _ => false,\\n },\\n _ => false,\\n }\\n}\\n\\nfn is_left_access_to_arguments(l: &PatOrExpr) -> bool {\\n match l {\\n PatOrExpr::Expr(e) => is_expr_access_to_arguments(&e),\\n PatOrExpr::Pat(pat) => match &**pat {\\n Pat::Expr(e) => is_expr_access_to_arguments(&e),\\n _ => false,\\n },\\n }\\n}\\n',\n", + " 'content_id': 'b863ee78372b1fbb4796c820cf673ff4e98d7e94',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/minifier/src/compress/optimize/mod.rs',\n", + " 'size': 79637,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.31791663143654353,\n", + " 'avg_line_length': 42.58845208845209,\n", + " 'blob_id': 'ad26b61dc4fb72cf23fb99306407cb427206d2f8',\n", + " 'content': 'pub use super::util::Config;\\nuse super::util::{\\n define_es_module, define_property, has_use_strict, initialize_to_undefined, make_descriptor,\\n make_require_call, use_strict, ModulePass, Scope,\\n};\\nuse crate::path::{ImportResolver, NoopImportResolver};\\nuse rustc_hash::FxHashSet;\\nuse std::{\\n cell::{Ref, RefCell, RefMut},\\n rc::Rc,\\n};\\nuse swc_atoms::js_word;\\nuse swc_common::{FileName, Mark, Span, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::helper;\\nuse swc_ecma_utils::{\\n ident::IdentLike, member_expr, private_ident, quote_ident, quote_str, var::VarCollector,\\n DestructuringFinder, ExprFactory, IsDirective,\\n};\\nuse swc_ecma_visit::{noop_fold_type, Fold, FoldWith, VisitWith};\\n\\npub fn common_js(\\n top_level_mark: Mark,\\n config: Config,\\n scope: Option>>,\\n) -> impl Fold {\\n let scope = scope.unwrap_or_default();\\n CommonJs {\\n top_level_mark,\\n config,\\n scope,\\n in_top_level: Default::default(),\\n resolver: None::<(NoopImportResolver, _)>,\\n }\\n}\\n\\npub fn common_js_with_resolver(\\n resolver: R,\\n base: FileName,\\n top_level_mark: Mark,\\n config: Config,\\n scope: Option>>,\\n) -> impl Fold\\nwhere\\n R: ImportResolver,\\n{\\n let scope = scope.unwrap_or_default();\\n\\n CommonJs {\\n top_level_mark,\\n config,\\n scope,\\n in_top_level: Default::default(),\\n resolver: Some((resolver, base)),\\n }\\n}\\n\\nstruct CommonJs

\\nwhere\\n P: ImportResolver,\\n{\\n top_level_mark: Mark,\\n config: Config,\\n scope: Rc>,\\n in_top_level: bool,\\n resolver: Option<(P, FileName)>,\\n}\\n\\nimpl

Fold for CommonJs

\\nwhere\\n P: ImportResolver,\\n{\\n noop_fold_type!();\\n\\n fn fold_module_items(&mut self, items: Vec) -> Vec {\\n let mut emitted_esmodule = false;\\n let mut stmts = Vec::with_capacity(items.len() + 4);\\n let mut extra_stmts = Vec::with_capacity(items.len());\\n\\n if self.config.strict_mode && !has_use_strict(&items) {\\n stmts.push(ModuleItem::Stmt(use_strict()));\\n }\\n\\n let mut exports = vec![];\\n let mut initialized = FxHashSet::default();\\n let mut export_alls = vec![];\\n\\n for item in items {\\n self.in_top_level = true;\\n\\n match item {\\n ModuleItem::Stmt(ref s) if s.is_use_strict() => {\\n stmts.push(item);\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => {\\n self.scope.borrow_mut().insert_import(import)\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportAll(..))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(..))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(..))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(..))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(..)) => {\\n if !self.config.strict && !emitted_esmodule {\\n emitted_esmodule = true;\\n\\n stmts.push(ModuleItem::Stmt(define_es_module(quote_ident!(\"exports\"))));\\n }\\n\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n macro_rules! init_export {\\n (\"default\") => {{\\n init_export!(js_word!(\"default\"))\\n }};\\n ($name:expr) => {{\\n exports.push($name.clone());\\n initialized.insert($name.clone());\\n }};\\n }\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(\\n ExportDefaultDecl {\\n decl: DefaultDecl::Fn(..),\\n ..\\n },\\n )) => {\\n // initialized.insert(js_word!(\"default\"));\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(\\n ExportDefaultDecl {\\n decl: DefaultDecl::TsInterfaceDecl(..),\\n ..\\n },\\n )) => {}\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportAll(ref export)) => {\\n scope.import_to_export(&export.src, true);\\n\\n scope\\n .import_types\\n .entry(export.src.value.clone())\\n .and_modify(|v| *v = true);\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(..))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(..)) => {\\n init_export!(\"default\")\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {\\n src: Some(ref src),\\n ref specifiers,\\n ..\\n })) => {\\n scope.import_to_export(&src, !specifiers.is_empty());\\n }\\n _ => {}\\n }\\n drop(scope);\\n drop(scope_ref_mut);\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportAll(export)) => {\\n self.scope\\n .borrow_mut()\\n .lazy_blacklist\\n .insert(export.src.value.clone());\\n\\n export_alls.push(export);\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: decl @ Decl::Class(..),\\n ..\\n }))\\n | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: decl @ Decl::Fn(..),\\n ..\\n })) => {\\n let (ident, is_class) = match decl {\\n Decl::Class(ref c) => (c.ident.clone(), true),\\n Decl::Fn(ref f) => (f.ident.clone(), false),\\n _ => unreachable!(),\\n };\\n\\n //\\n extra_stmts.push(ModuleItem::Stmt(Stmt::Decl(decl.fold_with(self))));\\n\\n let append_to: &mut Vec<_> = if is_class {\\n &mut extra_stmts\\n } else {\\n // Function declaration cannot throw\\n &mut stmts\\n };\\n\\n append_to.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n quote_ident!(\"exports\").make_member(ident.clone()),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt()\\n .into(),\\n );\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Var(var),\\n ..\\n })) => {\\n extra_stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(\\n var.clone().fold_with(self),\\n ))));\\n\\n let mut scope = self.scope.borrow_mut();\\n var.decls.visit_with(\\n &Invalid { span: DUMMY_SP } as _,\\n &mut VarCollector {\\n to: &mut scope.declared_vars,\\n },\\n );\\n\\n let mut found: Vec = vec![];\\n for decl in var.decls {\\n let mut v = DestructuringFinder { found: &mut found };\\n decl.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n\\n for ident in found.drain(..) {\\n scope\\n .exported_vars\\n .entry((ident.sym.clone(), ident.span.ctxt()))\\n .or_default()\\n .push((ident.sym.clone(), ident.span.ctxt()));\\n init_export!(ident.sym);\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n quote_ident!(\"exports\").make_member(ident.clone()),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt()\\n .into(),\\n );\\n }\\n }\\n drop(scope);\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(..)) => {\\n //\\n extra_stmts.push(item.fold_with(self));\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(decl)) => {\\n match decl.decl {\\n DefaultDecl::Class(ClassExpr { ident, class }) => {\\n let class = class.fold_with(self);\\n\\n init_export!(\"default\");\\n\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_default\"));\\n\\n extra_stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Class(\\n ClassDecl {\\n ident: ident.clone(),\\n class,\\n declare: false,\\n },\\n ))));\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(member_expr!(\\n DUMMY_SP,\\n exports.default\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt()\\n .into(),\\n );\\n }\\n DefaultDecl::Fn(FnExpr { ident, function }) => {\\n // init_export!(\"default\");\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_default\"));\\n\\n extra_stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Fn(\\n FnDecl {\\n ident: ident.clone(),\\n function,\\n declare: false,\\n }\\n .fold_with(self),\\n ))));\\n\\n stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(member_expr!(\\n DUMMY_SP,\\n exports.default\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt()\\n .into(),\\n );\\n }\\n _ => extra_stmts.push(\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(decl))\\n .fold_with(self),\\n ),\\n }\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(expr)) => {\\n let ident = private_ident!(\"_default\");\\n\\n // TODO: Optimization (when expr cannot throw, `exports.default =\\n // void 0` is not required)\\n\\n // We use extra statements because of the initialization\\n extra_stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(ident.clone().into()),\\n init: Some(expr.expr.fold_with(self)),\\n definite: false,\\n }],\\n declare: false,\\n }))));\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(member_expr!(DUMMY_SP, exports.default)),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt()\\n .into(),\\n );\\n }\\n\\n // export { foo } from \\'foo\\';\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(export)) => {\\n let mut scope = self.scope.borrow_mut();\\n let imported = export.src.clone().map(|src| {\\n scope.import_to_export(&src, !export.specifiers.is_empty())\\n });\\n\\n stmts.reserve(export.specifiers.len());\\n\\n drop(scope);\\n\\n for ExportNamedSpecifier { orig, exported, .. } in export\\n .specifiers\\n .into_iter()\\n .map(|e| match e {\\n ExportSpecifier::Named(e) => e,\\n _ => unreachable!(\\n \"export default from \\'foo\\'; should be removed by previous \\\\\\n pass\"\\n ),\\n })\\n .filter(|e| !e.is_type_only)\\n {\\n let mut scope = self.scope.borrow_mut();\\n let is_import_default = orig.sym == js_word!(\"default\");\\n\\n let key = orig.to_id();\\n if scope.declared_vars.contains(&key) {\\n scope.exported_vars.entry(key.clone()).or_default().push(\\n exported\\n .clone()\\n .map(|i| (i.sym.clone(), i.span.ctxt()))\\n .unwrap_or_else(|| {\\n (orig.sym.clone(), orig.span.ctxt())\\n }),\\n );\\n }\\n\\n if let Some(ref src) = export.src {\\n if is_import_default {\\n scope\\n .import_types\\n .entry(src.value.clone())\\n .or_insert(false);\\n }\\n }\\n\\n let lazy = if let Some(ref src) = export.src {\\n if scope.lazy_blacklist.contains(&src.value) {\\n false\\n } else {\\n self.config.lazy.is_lazy(&src.value)\\n }\\n } else {\\n match scope.idents.get(&(orig.sym.clone(), orig.span.ctxt())) {\\n Some((ref src, _)) => {\\n if scope.lazy_blacklist.contains(src) {\\n false\\n } else {\\n self.config.lazy.is_lazy(src)\\n }\\n }\\n None => false,\\n }\\n };\\n\\n let is_reexport = export.src.is_some()\\n || scope\\n .idents\\n .contains_key(&(orig.sym.clone(), orig.span.ctxt()));\\n\\n drop(scope);\\n\\n let old = self.in_top_level;\\n\\n // When we are in top level we make import not lazy.\\n let is_top_level = if lazy { !is_reexport } else { true };\\n self.in_top_level = is_top_level;\\n\\n let value = match imported {\\n Some(ref imported) => Box::new(\\n imported.clone().unwrap().make_member(orig.clone()),\\n ),\\n None => Box::new(Expr::Ident(orig.clone()).fold_with(self)),\\n };\\n\\n // True if we are exporting our own stuff.\\n let is_value_ident = match *value {\\n Expr::Ident(..) => true,\\n _ => false,\\n };\\n\\n self.in_top_level = old;\\n\\n if is_value_ident {\\n let exported_symbol = exported\\n .as_ref()\\n .map(|e| e.sym.clone())\\n .unwrap_or_else(|| orig.sym.clone());\\n init_export!(exported_symbol);\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n quote_ident!(\"exports\")\\n .make_member(exported.unwrap_or(orig)),\\n )),\\n op: op!(\"=\"),\\n right: value,\\n }\\n .into_stmt()\\n .into(),\\n );\\n } else {\\n stmts.push(\\n define_property(vec![\\n quote_ident!(\"exports\").as_arg(),\\n {\\n // export { foo }\\n // -> \\'foo\\'\\n\\n // export { foo as bar }\\n // -> \\'bar\\'\\n let i = exported.unwrap_or_else(|| orig);\\n Lit::Str(quote_str!(i.span, i.sym)).as_arg()\\n },\\n make_descriptor(value).as_arg(),\\n ])\\n .into_stmt()\\n .into(),\\n );\\n }\\n }\\n }\\n\\n _ => unreachable!(),\\n }\\n }\\n _ => extra_stmts.push(item.fold_with(self)),\\n }\\n }\\n\\n let has_export = !exports.is_empty();\\n\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n // Used only if export * exists\\n let exported_names = {\\n if (!export_alls.is_empty() && has_export) || export_alls.len() >= 2 {\\n let exported_names = private_ident!(\"_exportNames\");\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(exported_names.clone().into()),\\n init: Some(Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: exports\\n .into_iter()\\n .filter_map(|export| {\\n if export == js_word!(\"default\") {\\n return None;\\n }\\n\\n Some(PropOrSpread::Prop(Box::new(Prop::KeyValue(\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(export, DUMMY_SP)),\\n value: Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n },\\n ))))\\n })\\n .collect(),\\n }))),\\n definite: false,\\n }],\\n declare: false,\\n }))));\\n\\n Some(exported_names)\\n } else {\\n None\\n }\\n };\\n\\n for export in export_alls {\\n // We use extra_stmts because it should be placed *after* import\\n // statements.\\n extra_stmts.push(ModuleItem::Stmt(scope.handle_export_all(\\n quote_ident!(\"exports\"),\\n exported_names.clone(),\\n export,\\n )));\\n }\\n\\n if !initialized.is_empty() {\\n stmts.push(\\n initialize_to_undefined(quote_ident!(\"exports\"), initialized)\\n .into_stmt()\\n .into(),\\n );\\n }\\n let scope = &mut *scope;\\n for (src, import) in scope.imports.drain(..) {\\n let lazy = if scope.lazy_blacklist.contains(&src) {\\n false\\n } else {\\n self.config.lazy.is_lazy(&src)\\n };\\n\\n let require = make_require_call(&self.resolver, self.top_level_mark, src.clone());\\n\\n match import {\\n Some(import) => {\\n let ty = scope.import_types.get(&src);\\n let rhs = match ty {\\n Some(true) if !self.config.no_interop => Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(interop_require_wildcard, \"interopRequireWildcard\"),\\n args: vec![require.as_arg()],\\n type_args: Default::default(),\\n })),\\n Some(false) if !self.config.no_interop => Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(interop_require_default, \"interopRequireDefault\"),\\n args: vec![require.as_arg()],\\n type_args: Default::default(),\\n })),\\n _ => Box::new(require),\\n };\\n\\n let ident = Ident::new(import.0, import.1);\\n\\n if lazy {\\n let return_data = Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(Box::new(quote_ident!(\"data\").into())),\\n });\\n\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Fn(FnDecl {\\n ident: ident.clone(),\\n function: Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![\\n // const data = require();\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Const,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(quote_ident!(\"data\").into()),\\n init: Some(rhs),\\n definite: false,\\n }],\\n declare: false,\\n })),\\n // foo = function() { return data; };\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(\\n ident.into(),\\n ))),\\n op: op!(\"=\"),\\n right: Box::new(\\n FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![return_data.clone()],\\n }),\\n params: vec![],\\n type_params: Default::default(),\\n return_type: Default::default(),\\n },\\n }\\n .into(),\\n ),\\n }\\n .into_stmt(),\\n // return data\\n return_data,\\n ],\\n }),\\n params: vec![],\\n type_params: Default::default(),\\n return_type: Default::default(),\\n },\\n declare: false,\\n }))));\\n } else {\\n stmts.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: import.1,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(ident.into()),\\n init: Some(rhs),\\n definite: false,\\n }],\\n declare: false,\\n }))));\\n }\\n }\\n None => {\\n stmts.push(require.into_stmt().into());\\n }\\n }\\n }\\n\\n stmts.append(&mut extra_stmts);\\n\\n stmts\\n }\\n\\n fn fold_expr(&mut self, expr: Expr) -> Expr {\\n let top_level = self.in_top_level;\\n Scope::fold_expr(self, quote_ident!(\"exports\"), top_level, expr)\\n }\\n\\n fn fold_prop(&mut self, p: Prop) -> Prop {\\n match p {\\n Prop::Shorthand(ident) => {\\n let top_level = self.in_top_level;\\n Scope::fold_shorthand_prop(self, top_level, ident)\\n }\\n\\n _ => p.fold_children_with(self),\\n }\\n }\\n\\n ///\\n /// - collects all declared variables for let and var.\\n fn fold_var_decl(&mut self, var: VarDecl) -> VarDecl {\\n if var.kind != VarDeclKind::Const {\\n var.decls.visit_with(\\n &Invalid { span: DUMMY_SP } as _,\\n &mut VarCollector {\\n to: &mut self.scope.borrow_mut().declared_vars,\\n },\\n );\\n }\\n\\n VarDecl {\\n decls: var.decls.fold_with(self),\\n ..var\\n }\\n }\\n\\n fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {\\n self.scope\\n .borrow_mut()\\n .declared_vars\\n .push((node.ident.sym.clone(), node.ident.span.ctxt()));\\n\\n node.fold_children_with(self)\\n }\\n\\n mark_as_nested!();\\n}\\n\\nimpl

ModulePass for CommonJs

\\nwhere\\n P: ImportResolver,\\n{\\n fn config(&self) -> &Config {\\n &self.config\\n }\\n\\n fn scope(&self) -> Ref {\\n self.scope.borrow()\\n }\\n\\n fn scope_mut(&mut self) -> RefMut {\\n self.scope.borrow_mut()\\n }\\n\\n fn make_dynamic_import(&mut self, span: Span, args: Vec) -> Expr {\\n handle_dynamic_import(span, args, !self.config.no_interop)\\n }\\n}\\n\\n/// ```js\\n/// Promise.resolve().then(function () { return require(\\'./foo\\'); })\\n/// ```\\npub(super) fn handle_dynamic_import(\\n span: Span,\\n args: Vec,\\n es_module_interop: bool,\\n) -> Expr {\\n let resolve_call = CallExpr {\\n span: DUMMY_SP,\\n callee: member_expr!(DUMMY_SP, Promise.resolve).as_callee(),\\n args: Default::default(),\\n type_args: Default::default(),\\n };\\n // Promise.resolve().then\\n let then = resolve_call.make_member(quote_ident!(\"then\"));\\n\\n return Expr::Call(CallExpr {\\n span,\\n callee: then.as_callee(),\\n args: vec![\\n // function () { return require(\\'./foo\\'); }\\n FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n params: vec![],\\n is_generator: false,\\n is_async: false,\\n type_params: Default::default(),\\n return_type: Default::default(),\\n decorators: Default::default(),\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some({\\n let mut expr = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"require\").as_callee(),\\n args,\\n type_args: Default::default(),\\n }));\\n\\n if es_module_interop {\\n expr = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(\\n interop_require_wildcard,\\n \"interopRequireWildcard\"\\n ),\\n args: vec![expr.as_arg()],\\n type_args: Default::default(),\\n }));\\n }\\n\\n expr\\n }),\\n })],\\n }),\\n },\\n }\\n .as_arg(),\\n ],\\n type_args: Default::default(),\\n });\\n}\\n',\n", + " 'content_id': 'a156b18eaf07c5e1e1a7f856e55eeb8bfd757957',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/transforms/module/src/common_js.rs',\n", + " 'size': 35481,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.64576802507837,\n", + " 'avg_line_length': 26.60576923076923,\n", + " 'blob_id': '29953d478a9500e41e3f27b8774da60d1a340e12',\n", + " 'content': '[workspace]\\nmembers = [\\n \"css\",\\n \"css/stylis\",\\n \"ecmascript\",\\n \"ecmascript/babel/compat\",\\n \"ecmascript/jsdoc\",\\n \"node/binding\",\\n \"plugin\",\\n \"plugin/runner\",\\n \"plugin/testing\",\\n \"wasm\",\\n]\\n\\n[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"Speedy web compiler\"\\ndocumentation = \"https://rustdoc.swc.rs/swc/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.66.0\"\\n\\n[lib]\\nname = \"swc\"\\n\\n[features]\\ndefault = [\"es3\"]\\n# You can disable this feautre to reduce binary size.\\nes3 = []\\n# See https://github.com/swc-project/swc/issues/1108\\n#\\n# If this option is enabled, es2015 transforms are enabled if target is es2015.\\n# If this option is disabled, es2015 transforms are disabled if target is es2015.\\n#\\n# This feature will be removed on v2 of node bindings.\\nwrong-target = []\\n\\n[dependencies]\\nahash = \"0.7.2\"\\nanyhow = \"1\"\\nbase64 = \"0.13.0\"\\ndashmap = \"4.0.2\"\\neither = \"1\"\\nlru = \"0.6.1\"\\nonce_cell = \"1\"\\npathdiff = \"0.2.0\"\\nregex = \"1\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1\", features = [\"derive\"]}\\nserde_json = \"1\"\\nsourcemap = \"6\"\\nswc_atoms = {version = \"0.2\", path = \"./atoms\"}\\nswc_bundler = {version = \"0.67.0\", path = \"./bundler\"}\\nswc_common = {version = \"0.13.0\", path = \"./common\", features = [\"sourcemap\", \"concurrent\"]}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"./ecmascript/ast\"}\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"./ecmascript/codegen\"}\\nswc_ecma_ext_transforms = {version = \"0.31.0\", path = \"./ecmascript/ext-transforms\"}\\nswc_ecma_loader = {version = \"0.20.0\", path = \"./ecmascript/loader\", features = [\"lru\", \"node\", \"tsc\"]}\\nswc_ecma_minifier = {version = \"0.36.0\", path = \"./ecmascript/minifier\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"./ecmascript/parser\"}\\nswc_ecma_preset_env = {version = \"0.51.0\", path = \"./ecmascript/preset-env\"}\\nswc_ecma_transforms = {version = \"0.80.0\", path = \"./ecmascript/transforms\", features = [\\n \"compat\",\\n \"module\",\\n \"optimization\",\\n \"proposal\",\\n \"react\",\\n \"typescript\",\\n]}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"./ecmascript/transforms/base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"./ecmascript/utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"./ecmascript/visit\"}\\nswc_ecmascript = {version = \"0.72.0\", path = \"./ecmascript\"}\\nswc_visit = {version = \"0.2.3\", path = \"./visit\"}\\ntracing = \"0.1.28\"\\n\\n[dev-dependencies]\\nrayon = \"1\"\\nswc_node_base = {version = \"0.4.0\", path = \"./node/base\"}\\ntesting = {version = \"0.14.0\", path = \"./testing\"}\\nwalkdir = \"2\"\\n\\n[[example]]\\nname = \"usage\"\\n\\n[profile.release]\\ncodegen-units = 1\\nlto = true\\n# debug = true\\n# opt-level = \\'z\\'\\n\\n[profile.bench]\\ncodegen-units = 1\\ndebug = true\\n\\n# Without this, printing diff consumes more than a minute.\\n\\n[profile.dev.package.pretty_assertions]\\nopt-level = 3\\n\\n[profile.test.package.pretty_assertions]\\nopt-level = 3\\n',\n", + " 'content_id': '1c11a93fd002d62a3d39ce5354dc16811251c5a1',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 103,\n", + " 'path': '/Cargo.toml',\n", + " 'size': 2871,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.40677911852254905,\n", + " 'avg_line_length': 28.336150234741783,\n", + " 'blob_id': 'dd53a573ac5543bc4165f267ea01fa8729b7e885',\n", + " 'content': 'use super::{pat::PatType, *};\\nuse crate::error::SyntaxError;\\nuse swc_atoms::js_word;\\nuse swc_common::Spanned;\\n\\nmod module_item;\\n\\nimpl<\\'a, I: Tokens> Parser {\\n pub(super) fn parse_block_body(\\n &mut self,\\n mut allow_directives: bool,\\n top_level: bool,\\n end: Option<&Token>,\\n ) -> PResult>\\n where\\n Self: StmtLikeParser<\\'a, Type>,\\n Type: IsDirective + From,\\n {\\n trace_cur!(self, parse_block_body);\\n\\n let old_ctx = self.ctx();\\n\\n let mut stmts = Vec::with_capacity(32);\\n while {\\n let c = cur!(self, false).ok();\\n c != end\\n } {\\n let stmt = self.parse_stmt_like(true, top_level)?;\\n if allow_directives {\\n allow_directives = false;\\n if stmt.is_use_strict() {\\n let ctx = Context {\\n strict: true,\\n ..old_ctx\\n };\\n self.set_ctx(ctx);\\n\\n if self.input.knows_cur() && !is!(self, \\';\\') {\\n unreachable!(\\n \"\\'use strict\\'; directive requires parser.input.cur to be empty or \\\\\\n \\'}}\\', but current token was: {:?}\",\\n self.input.cur()\\n )\\n }\\n }\\n }\\n\\n stmts.push(stmt);\\n }\\n\\n if end.is_some() {\\n bump!(self);\\n }\\n\\n self.set_ctx(old_ctx);\\n\\n Ok(stmts)\\n }\\n\\n pub fn parse_stmt(&mut self, top_level: bool) -> PResult {\\n trace_cur!(self, parse_stmt);\\n self.parse_stmt_like(false, top_level)\\n }\\n\\n fn parse_stmt_list_item(&mut self, top_level: bool) -> PResult {\\n trace_cur!(self, parse_stmt_list_item);\\n self.parse_stmt_like(true, top_level)\\n }\\n\\n /// Parse a statement, declaration or module item.\\n fn parse_stmt_like(&mut self, include_decl: bool, top_level: bool) -> PResult\\n where\\n Self: StmtLikeParser<\\'a, Type>,\\n Type: IsDirective + From,\\n {\\n trace_cur!(self, parse_stmt_like);\\n let start = cur_pos!(self);\\n let decorators = self.parse_decorators(true)?;\\n\\n if is_one_of!(self, \"import\", \"export\") {\\n return self.handle_import_export(top_level, decorators);\\n }\\n\\n self.parse_stmt_internal(start, include_decl, top_level, decorators)\\n .map(From::from)\\n }\\n\\n /// `parseStatementContent`\\n #[allow(clippy::cognitive_complexity)]\\n fn parse_stmt_internal(\\n &mut self,\\n start: BytePos,\\n include_decl: bool,\\n top_level: bool,\\n decorators: Vec,\\n ) -> PResult {\\n trace_cur!(self, parse_stmt_internal);\\n\\n if top_level && is!(self, \"await\") {\\n let valid = self.target() >= JscTarget::Es2017 && self.syntax().top_level_await();\\n\\n if !valid {\\n self.emit_err(self.input.cur_span(), SyntaxError::TopLevelAwait);\\n }\\n\\n self.state.found_module_item = true;\\n if !self.ctx().can_be_module {\\n self.emit_err(self.input.cur_span(), SyntaxError::TopLevelAwaitInScript);\\n }\\n\\n let expr = self.parse_await_expr()?;\\n eat!(self, \\';\\');\\n\\n let span = span!(self, start);\\n return Ok(Stmt::Expr(ExprStmt { span, expr }));\\n }\\n\\n if self.input.syntax().typescript() && is!(self, \"const\") && peeked_is!(self, \"enum\") {\\n assert_and_bump!(self, \"const\");\\n assert_and_bump!(self, \"enum\");\\n return self\\n .parse_ts_enum_decl(start, true)\\n .map(Decl::from)\\n .map(Stmt::from);\\n }\\n\\n match cur!(self, true)? {\\n tok!(\"break\") | tok!(\"continue\") => {\\n let is_break = is!(self, \"break\");\\n bump!(self);\\n\\n let label = if eat!(self, \\';\\') {\\n None\\n } else {\\n let i = self.parse_label_ident().map(Some)?;\\n expect!(self, \\';\\');\\n i\\n };\\n\\n let span = span!(self, start);\\n if is_break {\\n if label.is_some() && !self.state.labels.contains(&label.as_ref().unwrap().sym)\\n {\\n self.emit_err(span, SyntaxError::TS1116);\\n } else if !self.ctx().is_break_allowed {\\n self.emit_err(span, SyntaxError::TS1105);\\n }\\n } else {\\n if !self.ctx().is_continue_allowed {\\n self.emit_err(span, SyntaxError::TS1115);\\n } else if label.is_some()\\n && !self.state.labels.contains(&label.as_ref().unwrap().sym)\\n {\\n self.emit_err(span, SyntaxError::TS1107);\\n }\\n }\\n\\n return Ok(if is_break {\\n Stmt::Break(BreakStmt { span, label })\\n } else {\\n Stmt::Continue(ContinueStmt { span, label })\\n });\\n }\\n\\n tok!(\"debugger\") => {\\n bump!(self);\\n expect!(self, \\';\\');\\n return Ok(Stmt::Debugger(DebuggerStmt {\\n span: span!(self, start),\\n }));\\n }\\n\\n tok!(\"do\") => {\\n return self.parse_do_stmt();\\n }\\n\\n tok!(\"for\") => {\\n return self.parse_for_stmt();\\n }\\n\\n tok!(\"function\") => {\\n if !include_decl {\\n self.emit_err(self.input.cur_span(), SyntaxError::DeclNotAllowed);\\n }\\n\\n return self.parse_fn_decl(decorators).map(Stmt::from);\\n }\\n\\n tok!(\"class\") => {\\n if !include_decl {\\n self.emit_err(self.input.cur_span(), SyntaxError::DeclNotAllowed);\\n }\\n return self\\n .parse_class_decl(start, start, decorators)\\n .map(Stmt::from);\\n }\\n\\n tok!(\"if\") => {\\n return self.parse_if_stmt();\\n }\\n\\n tok!(\"return\") => {\\n return self.parse_return_stmt();\\n }\\n\\n tok!(\"switch\") => {\\n return self.parse_switch_stmt();\\n }\\n\\n tok!(\"throw\") => {\\n return self.parse_throw_stmt();\\n }\\n\\n // Error recovery\\n tok!(\"catch\") => {\\n let span = self.input.cur_span();\\n self.emit_err(span, SyntaxError::TS1005);\\n\\n let _ = self.parse_catch_clause();\\n let _ = self.parse_finally_block();\\n\\n return Ok(Stmt::Expr(ExprStmt {\\n span,\\n expr: Box::new(Expr::Invalid(Invalid { span })),\\n }));\\n }\\n\\n // Error recovery\\n tok!(\"finally\") => {\\n let span = self.input.cur_span();\\n self.emit_err(span, SyntaxError::TS1005);\\n\\n let _ = self.parse_finally_block();\\n\\n return Ok(Stmt::Expr(ExprStmt {\\n span,\\n expr: Box::new(Expr::Invalid(Invalid { span })),\\n }));\\n }\\n\\n tok!(\"try\") => {\\n return self.parse_try_stmt();\\n }\\n\\n tok!(\"with\") => {\\n return self.parse_with_stmt();\\n }\\n\\n tok!(\"while\") => {\\n return self.parse_while_stmt();\\n }\\n\\n tok!(\"var\") => {\\n let v = self.parse_var_stmt(false)?;\\n return Ok(Stmt::Decl(Decl::Var(v)));\\n }\\n\\n tok!(\"const\") if include_decl => {\\n let v = self.parse_var_stmt(false)?;\\n return Ok(Stmt::Decl(Decl::Var(v)));\\n }\\n\\n // \\'let\\' can start an identifier reference.\\n tok!(\"let\") if include_decl => {\\n let strict = self.ctx().strict;\\n let is_keyword = match peek!(self) {\\n Ok(t) => t.follows_keyword_let(strict),\\n _ => false,\\n };\\n\\n if is_keyword {\\n let v = self.parse_var_stmt(false)?;\\n return Ok(Stmt::Decl(Decl::Var(v)));\\n }\\n }\\n\\n tok!(\\'{\\') => {\\n return self.parse_block(false).map(Stmt::Block);\\n }\\n\\n _ => {}\\n }\\n\\n if eat_exact!(self, \\';\\') {\\n return Ok(Stmt::Empty(EmptyStmt {\\n span: span!(self, start),\\n }));\\n }\\n\\n // Handle async function foo() {}\\n if is!(self, \"async\")\\n && peeked_is!(self, \"function\")\\n && !self.input.has_linebreak_between_cur_and_peeked()\\n {\\n return self.parse_async_fn_decl(decorators).map(From::from);\\n }\\n\\n // If the statement does not start with a statement keyword or a\\n // brace, it\\'s an ExpressionStatement or LabeledStatement. We\\n // simply start parsing an expression, and afterwards, if the\\n // next token is a colon and the expression was a simple\\n // Identifier node, we switch to interpreting it as a label.\\n let expr = self.include_in_expr(true).parse_expr()?;\\n\\n let expr = match *expr {\\n Expr::Ident(ident) => {\\n if eat!(self, \\':\\') {\\n return self.parse_labelled_stmt(ident);\\n }\\n Box::new(Expr::Ident(ident))\\n }\\n _ => self.verify_expr(expr)?,\\n };\\n if let Expr::Ident(ref ident) = *expr {\\n if *ident.sym == js_word!(\"interface\") && self.input.had_line_break_before_cur() {\\n self.emit_strict_mode_err(ident.span, SyntaxError::InvalidIdentInStrict);\\n\\n eat!(self, \\';\\');\\n\\n return Ok(Stmt::Expr(ExprStmt {\\n span: span!(self, start),\\n expr,\\n }));\\n }\\n\\n if self.input.syntax().typescript() {\\n if let Some(decl) = self.parse_ts_expr_stmt(decorators, ident.clone())? {\\n return Ok(Stmt::Decl(decl));\\n }\\n }\\n }\\n\\n match *expr {\\n Expr::Ident(Ident { ref sym, span, .. }) => match *sym {\\n js_word!(\"enum\") | js_word!(\"interface\") => {\\n self.emit_strict_mode_err(span, SyntaxError::InvalidIdentInStrict);\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n\\n if self.syntax().typescript() {\\n match *expr {\\n Expr::Ident(ref i) => match i.sym {\\n js_word!(\"public\") | js_word!(\"static\") | js_word!(\"abstract\") => {\\n if eat!(self, \"interface\") {\\n self.emit_err(i.span, SyntaxError::TS2427);\\n return self\\n .parse_ts_interface_decl(start)\\n .map(Decl::from)\\n .map(Stmt::from);\\n }\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n }\\n\\n if eat!(self, \\';\\') {\\n Ok(Stmt::Expr(ExprStmt {\\n span: span!(self, start),\\n expr,\\n }))\\n } else {\\n match *cur!(self, false)? {\\n Token::BinOp(..) => {\\n self.emit_err(self.input.cur_span(), SyntaxError::TS1005);\\n let expr = self.parse_bin_op_recursively(expr, 0)?;\\n return Ok(ExprStmt {\\n span: span!(self, start),\\n expr,\\n }\\n .into());\\n }\\n\\n _ => {}\\n }\\n\\n syntax_error!(\\n self,\\n SyntaxError::ExpectedSemiForExprStmt { expr: expr.span() }\\n );\\n }\\n }\\n\\n fn parse_if_stmt(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"if\");\\n\\n expect!(self, \\'(\\');\\n let test = self.include_in_expr(true).parse_expr()?;\\n if !eat!(self, \\')\\') {\\n self.emit_err(self.input.cur_span(), SyntaxError::TS1005);\\n\\n let span = span!(self, start);\\n return Ok(Stmt::If(IfStmt {\\n span,\\n test,\\n cons: Box::new(Stmt::Expr(ExprStmt {\\n span,\\n expr: Box::new(Expr::Invalid(Invalid { span })),\\n })),\\n alt: Default::default(),\\n }));\\n }\\n\\n let cons = {\\n // Annex B\\n if !self.ctx().strict && is!(self, \"function\") {\\n // TODO: report error?\\n }\\n self.parse_stmt(false).map(Box::new)?\\n };\\n\\n let alt = if eat!(self, \"else\") {\\n Some(self.parse_stmt(false).map(Box::new)?)\\n } else {\\n None\\n };\\n\\n let span = span!(self, start);\\n Ok(Stmt::If(IfStmt {\\n span,\\n test,\\n cons,\\n alt,\\n }))\\n }\\n\\n fn parse_return_stmt(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n let stmt = self.parse_with(|p| {\\n assert_and_bump!(p, \"return\");\\n\\n let arg = if is!(p, \\';\\') {\\n None\\n } else {\\n p.include_in_expr(true).parse_expr().map(Some)?\\n };\\n expect!(p, \\';\\');\\n Ok(Stmt::Return(ReturnStmt {\\n span: span!(p, start),\\n arg,\\n }))\\n });\\n\\n if !self.ctx().in_function {\\n self.emit_err(span!(self, start), SyntaxError::ReturnNotAllowed);\\n }\\n\\n stmt\\n }\\n\\n #[allow(clippy::cognitive_complexity)]\\n fn parse_switch_stmt(&mut self) -> PResult {\\n let switch_start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"switch\");\\n\\n expect!(self, \\'(\\');\\n let discriminant = self.include_in_expr(true).parse_expr()?;\\n expect!(self, \\')\\');\\n\\n let mut cases = vec![];\\n let mut span_of_previous_default = None;\\n\\n expect!(self, \\'{\\');\\n let ctx = Context {\\n is_break_allowed: true,\\n ..self.ctx()\\n };\\n\\n self.with_ctx(ctx).parse_with(|p| {\\n while is_one_of!(p, \"case\", \"default\") {\\n let mut cons = vec![];\\n let is_case = is!(p, \"case\");\\n let case_start = cur_pos!(p);\\n bump!(p);\\n let ctx = Context {\\n dont_parse_colon_as_type_ann: true,\\n ..p.ctx()\\n };\\n let test = if is_case {\\n p.with_ctx(ctx)\\n .include_in_expr(true)\\n .parse_expr()\\n .map(Some)?\\n } else {\\n if let Some(previous) = span_of_previous_default {\\n syntax_error!(p, SyntaxError::MultipleDefault { previous });\\n }\\n span_of_previous_default = Some(span!(p, case_start));\\n\\n None\\n };\\n expect!(p, \\':\\');\\n\\n while !eof!(p) && !is_one_of!(p, \"case\", \"default\", \\'}\\') {\\n cons.push(p.parse_stmt_list_item(false)?);\\n }\\n\\n cases.push(SwitchCase {\\n span: Span::new(case_start, p.input.prev_span().hi, Default::default()),\\n test,\\n cons,\\n });\\n }\\n\\n Ok(())\\n })?;\\n\\n // eof or rbrace\\n expect!(self, \\'}\\');\\n\\n Ok(Stmt::Switch(SwitchStmt {\\n span: span!(self, switch_start),\\n discriminant,\\n cases,\\n }))\\n }\\n\\n fn parse_throw_stmt(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"throw\");\\n\\n if self.input.had_line_break_before_cur() {\\n // TODO: Suggest throw arg;\\n syntax_error!(self, SyntaxError::LineBreakInThrow);\\n }\\n\\n let arg = self.include_in_expr(true).parse_expr()?;\\n expect!(self, \\';\\');\\n\\n let span = span!(self, start);\\n Ok(Stmt::Throw(ThrowStmt { span, arg }))\\n }\\n\\n fn parse_try_stmt(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n assert_and_bump!(self, \"try\");\\n\\n let block = self.parse_block(false)?;\\n\\n let catch_start = cur_pos!(self);\\n let handler = self.parse_catch_clause()?;\\n let finalizer = self.parse_finally_block()?;\\n\\n if handler.is_none() && finalizer.is_none() {\\n self.emit_err(\\n Span::new(catch_start, catch_start, Default::default()),\\n SyntaxError::TS1005,\\n );\\n }\\n\\n let span = span!(self, start);\\n Ok(Stmt::Try(TryStmt {\\n span,\\n block,\\n handler,\\n finalizer,\\n }))\\n }\\n\\n fn parse_catch_clause(&mut self) -> PResult> {\\n let start = cur_pos!(self);\\n\\n Ok(if eat!(self, \"catch\") {\\n let param = self.parse_catch_param()?;\\n\\n self.parse_block(false)\\n .map(|body| CatchClause {\\n span: span!(self, start),\\n param,\\n body,\\n })\\n .map(Some)?\\n } else {\\n None\\n })\\n }\\n\\n fn parse_finally_block(&mut self) -> PResult> {\\n Ok(if eat!(self, \"finally\") {\\n self.parse_block(false).map(Some)?\\n } else {\\n None\\n })\\n }\\n\\n /// It\\'s optional since es2019\\n fn parse_catch_param(&mut self) -> PResult> {\\n if eat!(self, \\'(\\') {\\n let mut pat = self.parse_binding_pat_or_ident()?;\\n\\n let type_ann_start = cur_pos!(self);\\n\\n if self.syntax().typescript() && eat!(self, \\':\\') {\\n let ctx = Context {\\n in_type: true,\\n ..self.ctx()\\n };\\n\\n let ty = self.with_ctx(ctx).parse_with(|p| p.parse_ts_type())?;\\n // self.emit_err(ty.span(), SyntaxError::TS1196);\\n\\n match &mut pat {\\n Pat::Ident(BindingIdent { type_ann, .. })\\n | Pat::Array(ArrayPat { type_ann, .. })\\n | Pat::Rest(RestPat { type_ann, .. })\\n | Pat::Object(ObjectPat { type_ann, .. })\\n | Pat::Assign(AssignPat { type_ann, .. }) => {\\n *type_ann = Some(TsTypeAnn {\\n span: span!(self, type_ann_start),\\n type_ann: ty,\\n });\\n }\\n Pat::Invalid(_) => {}\\n Pat::Expr(_) => {}\\n }\\n }\\n expect!(self, \\')\\');\\n Ok(Some(pat))\\n } else {\\n Ok(None)\\n }\\n }\\n\\n pub(super) fn parse_var_stmt(&mut self, for_loop: bool) -> PResult {\\n let start = cur_pos!(self);\\n let kind = match bump!(self) {\\n tok!(\"const\") => VarDeclKind::Const,\\n tok!(\"let\") => VarDeclKind::Let,\\n tok!(\"var\") => VarDeclKind::Var,\\n _ => unreachable!(),\\n };\\n let var_span = span!(self, start);\\n let should_include_in = kind != VarDeclKind::Var || !for_loop;\\n\\n if self.syntax().typescript() && for_loop {\\n let res = if is_one_of!(self, \"in\", \"of\") {\\n self.ts_look_ahead(|p| {\\n //\\n if !eat!(p, \"of\") && !eat!(p, \"in\") {\\n return Ok(false);\\n }\\n\\n p.parse_assignment_expr()?;\\n expect!(p, \\')\\');\\n\\n Ok(true)\\n })\\n } else {\\n Ok(false)\\n };\\n\\n match res {\\n Ok(true) => {\\n let pos = var_span.hi();\\n let span = Span::new(pos, pos, Default::default());\\n self.emit_err(span, SyntaxError::TS1123);\\n\\n return Ok(VarDecl {\\n span: span!(self, start),\\n kind,\\n declare: false,\\n decls: vec![],\\n });\\n }\\n Err(..) => {}\\n _ => {}\\n }\\n }\\n\\n let mut decls = vec![];\\n let mut first = true;\\n while first || eat!(self, \\',\\') {\\n if first {\\n first = false;\\n }\\n\\n let ctx = if should_include_in {\\n Context {\\n include_in_expr: true,\\n ..self.ctx()\\n }\\n } else {\\n self.ctx()\\n };\\n\\n // Handle\\n // var a,;\\n //\\n // NewLine is ok\\n if is_exact!(self, \\';\\') || eof!(self) {\\n let prev_span = self.input.prev_span();\\n let span = if prev_span == var_span {\\n Span::new(prev_span.hi, prev_span.hi, Default::default())\\n } else {\\n prev_span\\n };\\n self.emit_err(span, SyntaxError::TS1009);\\n break;\\n }\\n\\n decls.push(self.with_ctx(ctx).parse_var_declarator(for_loop)?);\\n }\\n\\n if !for_loop {\\n if !eat!(self, \\';\\') {\\n self.emit_err(self.input.cur_span(), SyntaxError::TS1005);\\n\\n let _ = self.parse_expr();\\n\\n while !eat!(self, \\';\\') {\\n bump!(self);\\n }\\n }\\n }\\n\\n Ok(VarDecl {\\n span: span!(self, start),\\n declare: false,\\n kind,\\n decls,\\n })\\n }\\n\\n fn parse_var_declarator(&mut self, for_loop: bool) -> PResult {\\n let start = cur_pos!(self);\\n\\n let mut name = self.parse_binding_pat_or_ident()?;\\n\\n let definite = if self.input.syntax().typescript() {\\n match name {\\n Pat::Ident(..) => eat!(self, \\'!\\'),\\n _ => false,\\n }\\n } else {\\n false\\n };\\n\\n // Typescript extension\\n if self.input.syntax().typescript() && is!(self, \\':\\') {\\n let type_annotation = self.try_parse_ts_type_ann()?;\\n match name {\\n Pat::Array(ArrayPat {\\n ref mut type_ann, ..\\n })\\n | Pat::Assign(AssignPat {\\n ref mut type_ann, ..\\n })\\n | Pat::Ident(BindingIdent {\\n ref mut type_ann, ..\\n })\\n | Pat::Object(ObjectPat {\\n ref mut type_ann, ..\\n })\\n | Pat::Rest(RestPat {\\n ref mut type_ann, ..\\n }) => {\\n *type_ann = type_annotation;\\n }\\n _ => unreachable!(\"invalid syntax: Pat: {:?}\", name),\\n }\\n }\\n\\n //FIXME: This is wrong. Should check in/of only on first loop.\\n let init = if !for_loop || !is_one_of!(self, \"in\", \"of\") {\\n if eat!(self, \\'=\\') {\\n let expr = self.parse_assignment_expr()?;\\n let expr = self.verify_expr(expr)?;\\n\\n Some(expr)\\n } else {\\n // Destructuring bindings require initializers, but\\n // typescript allows `declare` vars not to have initializers.\\n if self.ctx().in_declare {\\n None\\n } else {\\n match name {\\n Pat::Ident(..) => None,\\n _ => {\\n syntax_error!(self, span!(self, start), SyntaxError::PatVarWithoutInit)\\n }\\n }\\n }\\n }\\n } else {\\n // e.g. for(let a;;)\\n None\\n };\\n\\n Ok(VarDeclarator {\\n span: span!(self, start),\\n name,\\n init,\\n definite,\\n })\\n }\\n\\n #[allow(clippy::cognitive_complexity)]\\n fn parse_do_stmt(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"do\");\\n\\n let ctx = Context {\\n is_break_allowed: true,\\n is_continue_allowed: true,\\n ..self.ctx()\\n };\\n let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;\\n expect!(self, \"while\");\\n expect!(self, \\'(\\');\\n let test = self.include_in_expr(true).parse_expr()?;\\n expect!(self, \\')\\');\\n // We *may* eat semicolon.\\n let _ = eat!(self, \\';\\');\\n\\n let span = span!(self, start);\\n\\n Ok(Stmt::DoWhile(DoWhileStmt { span, test, body }))\\n }\\n\\n fn parse_while_stmt(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"while\");\\n\\n expect!(self, \\'(\\');\\n let test = self.include_in_expr(true).parse_expr()?;\\n expect!(self, \\')\\');\\n\\n let ctx = Context {\\n is_break_allowed: true,\\n is_continue_allowed: true,\\n ..self.ctx()\\n };\\n let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;\\n\\n let span = span!(self, start);\\n Ok(Stmt::While(WhileStmt { span, test, body }))\\n }\\n\\n fn parse_with_stmt(&mut self) -> PResult {\\n if self.syntax().typescript() {\\n let span = self.input.cur_span();\\n self.emit_err(span, SyntaxError::TS2410);\\n }\\n\\n {\\n let span = self.input.cur_span();\\n self.emit_strict_mode_err(span, SyntaxError::WithInStrict);\\n }\\n\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"with\");\\n\\n expect!(self, \\'(\\');\\n let obj = self.include_in_expr(true).parse_expr()?;\\n expect!(self, \\')\\');\\n\\n let ctx = Context {\\n in_function: true,\\n ..self.ctx()\\n };\\n let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;\\n\\n let span = span!(self, start);\\n Ok(Stmt::With(WithStmt { span, obj, body }))\\n }\\n\\n pub(super) fn parse_block(&mut self, allow_directives: bool) -> PResult {\\n let start = cur_pos!(self);\\n\\n expect!(self, \\'{\\');\\n\\n let stmts = self.parse_block_body(allow_directives, false, Some(&tok!(\\'}\\')))?;\\n\\n let span = span!(self, start);\\n Ok(BlockStmt { span, stmts })\\n }\\n\\n fn parse_labelled_stmt(&mut self, l: Ident) -> PResult {\\n let ctx = Context {\\n is_break_allowed: true,\\n ..self.ctx()\\n };\\n self.with_ctx(ctx).parse_with(|p| {\\n let start = l.span.lo();\\n\\n for lb in &p.state.labels {\\n if l.sym == *lb {\\n p.emit_err(l.span, SyntaxError::DuplicateLabel(l.sym.clone()));\\n }\\n }\\n p.state.labels.push(l.sym.clone());\\n\\n let body = Box::new(if is!(p, \"function\") {\\n let f = p.parse_fn_decl(vec![])?;\\n match f {\\n Decl::Fn(FnDecl {\\n function:\\n Function {\\n span,\\n is_generator: true,\\n ..\\n },\\n ..\\n }) => syntax_error!(p, span, SyntaxError::LabelledGenerator),\\n _ => {}\\n }\\n\\n f.into()\\n } else {\\n p.parse_stmt(false)?\\n });\\n\\n {\\n let pos = p.state.labels.iter().position(|v| v == &l.sym);\\n if let Some(pos) = pos {\\n p.state.labels.remove(pos);\\n }\\n }\\n\\n Ok(Stmt::Labeled(LabeledStmt {\\n span: span!(p, start),\\n label: l,\\n body,\\n }))\\n })\\n }\\n\\n fn parse_for_stmt(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"for\");\\n let await_start = cur_pos!(self);\\n let await_token = if eat!(self, \"await\") {\\n Some(span!(self, await_start))\\n } else {\\n None\\n };\\n expect!(self, \\'(\\');\\n let head = self.parse_for_head()?;\\n expect!(self, \\')\\');\\n let ctx = Context {\\n is_break_allowed: true,\\n is_continue_allowed: true,\\n ..self.ctx()\\n };\\n let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;\\n\\n let span = span!(self, start);\\n Ok(match head {\\n ForHead::For { init, test, update } => {\\n if let Some(await_token) = await_token {\\n syntax_error!(self, await_token, SyntaxError::AwaitForStmt);\\n }\\n\\n Stmt::For(ForStmt {\\n span,\\n init,\\n test,\\n update,\\n body,\\n })\\n }\\n ForHead::ForIn { left, right } => {\\n if let Some(await_token) = await_token {\\n syntax_error!(self, await_token, SyntaxError::AwaitForStmt);\\n }\\n\\n Stmt::ForIn(ForInStmt {\\n span,\\n left,\\n right,\\n body,\\n })\\n }\\n ForHead::ForOf { left, right } => Stmt::ForOf(ForOfStmt {\\n span,\\n await_token,\\n left,\\n right,\\n body,\\n }),\\n })\\n }\\n\\n fn parse_for_head(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n let strict = self.ctx().strict;\\n\\n if is_one_of!(self, \"const\", \"var\")\\n || (is!(self, \"let\") && peek!(self)?.follows_keyword_let(strict))\\n {\\n let decl = self.parse_var_stmt(true)?;\\n\\n if is_one_of!(self, \"of\", \"in\") {\\n let is_in = is!(self, \"in\");\\n\\n if decl.decls.len() != 1 {\\n for d in decl.decls.iter().skip(1) {\\n self.emit_err(d.name.span(), SyntaxError::TooManyVarInForInHead);\\n }\\n } else {\\n if decl.decls[0].init.is_some() {\\n self.emit_err(\\n decl.decls[0].name.span(),\\n SyntaxError::VarInitializerInForInHead,\\n );\\n }\\n\\n if self.syntax().typescript() {\\n let type_ann = match decl.decls[0].name {\\n Pat::Ident(ref v) => Some(&v.type_ann),\\n Pat::Array(ref v) => Some(&v.type_ann),\\n Pat::Assign(ref v) => Some(&v.type_ann),\\n Pat::Rest(ref v) => Some(&v.type_ann),\\n Pat::Object(ref v) => Some(&v.type_ann),\\n _ => None,\\n };\\n\\n if let Some(type_ann) = type_ann {\\n if type_ann.is_some() {\\n self.emit_err(decl.decls[0].name.span(), SyntaxError::TS2483);\\n }\\n }\\n }\\n }\\n\\n return self.parse_for_each_head(VarDeclOrPat::VarDecl(decl));\\n }\\n\\n expect_exact!(self, \\';\\');\\n return self.parse_normal_for_head(Some(VarDeclOrExpr::VarDecl(decl)));\\n }\\n\\n let init = if eat_exact!(self, \\';\\') {\\n return self.parse_normal_for_head(None);\\n } else {\\n self.include_in_expr(false).parse_expr_or_pat()?\\n };\\n\\n // for (a of b)\\n if is_one_of!(self, \"of\", \"in\") {\\n let is_in = is!(self, \"in\");\\n\\n let pat = self.reparse_expr_as_pat(PatType::AssignPat, init)?;\\n\\n // for ({} in foo) is invalid\\n if self.input.syntax().typescript() && is_in {\\n match pat {\\n Pat::Ident(ref v) => {}\\n Pat::Expr(..) => {}\\n ref v => self.emit_err(v.span(), SyntaxError::TS2491),\\n }\\n }\\n\\n return self.parse_for_each_head(VarDeclOrPat::Pat(pat));\\n }\\n\\n expect_exact!(self, \\';\\');\\n\\n let init = self.verify_expr(init)?;\\n self.parse_normal_for_head(Some(VarDeclOrExpr::Expr(init)))\\n }\\n\\n fn parse_for_each_head(&mut self, left: VarDeclOrPat) -> PResult {\\n let of = bump!(self) == tok!(\"of\");\\n if of {\\n let right = self.include_in_expr(true).parse_assignment_expr()?;\\n Ok(ForHead::ForOf { left, right })\\n } else {\\n let right = self.include_in_expr(true).parse_expr()?;\\n Ok(ForHead::ForIn { left, right })\\n }\\n }\\n\\n fn parse_normal_for_head(&mut self, init: Option) -> PResult {\\n let test = if eat_exact!(self, \\';\\') {\\n None\\n } else {\\n let test = self.include_in_expr(true).parse_expr().map(Some)?;\\n expect_exact!(self, \\';\\');\\n test\\n };\\n\\n let update = if is!(self, \\')\\') {\\n None\\n } else {\\n self.include_in_expr(true).parse_expr().map(Some)?\\n };\\n\\n Ok(ForHead::For { init, test, update })\\n }\\n}\\n\\nenum ForHead {\\n For {\\n init: Option,\\n test: Option>,\\n update: Option>,\\n },\\n ForIn {\\n left: VarDeclOrPat,\\n right: Box,\\n },\\n ForOf {\\n left: VarDeclOrPat,\\n right: Box,\\n },\\n}\\n\\npub(super) trait IsDirective {\\n fn as_ref(&self) -> Option<&Stmt>;\\n fn is_use_strict(&self) -> bool {\\n match self.as_ref() {\\n Some(&Stmt::Expr(ref expr)) => match *expr.expr {\\n Expr::Lit(Lit::Str(Str {\\n ref value,\\n has_escape: false,\\n ..\\n })) => value == \"use strict\",\\n _ => false,\\n },\\n _ => false,\\n }\\n }\\n}\\n\\nimpl IsDirective for Stmt {\\n fn as_ref(&self) -> Option<&Stmt> {\\n Some(self)\\n }\\n}\\n\\npub(super) trait StmtLikeParser<\\'a, Type: IsDirective> {\\n fn handle_import_export(\\n &mut self,\\n top_level: bool,\\n decorators: Vec,\\n ) -> PResult;\\n}\\n\\nimpl<\\'a, I: Tokens> StmtLikeParser<\\'a, Stmt> for Parser {\\n fn handle_import_export(&mut self, top_level: bool, _: Vec) -> PResult {\\n let start = cur_pos!(self);\\n if self.input.syntax().dynamic_import() && is!(self, \"import\") && peeked_is!(self, \\'(\\') {\\n let expr = self.parse_expr()?;\\n\\n eat!(self, \\';\\');\\n\\n return Ok(ExprStmt {\\n span: span!(self, start),\\n expr,\\n }\\n .into());\\n }\\n\\n if self.input.syntax().import_meta() && is!(self, \"import\") && peeked_is!(self, \\'.\\') {\\n let expr = self.parse_expr()?;\\n\\n eat!(self, \\';\\');\\n\\n return Ok(ExprStmt {\\n span: span!(self, start),\\n expr,\\n }\\n .into());\\n }\\n\\n syntax_error!(self, SyntaxError::ImportExportInScript);\\n }\\n}\\n\\n#[cfg(test)]\\nmod tests {\\n use super::*;\\n use crate::{EsConfig, TsConfig};\\n use swc_common::{comments::SingleThreadedComments, DUMMY_SP as span};\\n use swc_ecma_visit::assert_eq_ignore_span;\\n\\n fn stmt(s: &\\'static str) -> Stmt {\\n test_parser(s, Syntax::default(), |p| p.parse_stmt(true))\\n }\\n\\n fn module_item(s: &\\'static str) -> ModuleItem {\\n test_parser(s, Syntax::default(), |p| p.parse_stmt_like(true, true))\\n }\\n fn expr(s: &\\'static str) -> Box {\\n test_parser(s, Syntax::default(), |p| p.parse_expr())\\n }\\n\\n #[test]\\n fn expr_stmt() {\\n assert_eq_ignore_span!(\\n stmt(\"a + b + c\"),\\n Stmt::Expr(ExprStmt {\\n span,\\n expr: expr(\"a + b + c\")\\n })\\n )\\n }\\n\\n #[test]\\n fn catch_rest_pat() {\\n assert_eq_ignore_span!(\\n stmt(\"try {} catch({ ...a34 }) {}\"),\\n Stmt::Try(TryStmt {\\n span,\\n block: BlockStmt {\\n span,\\n stmts: vec![]\\n },\\n handler: Some(CatchClause {\\n span,\\n param: Pat::Object(ObjectPat {\\n span,\\n optional: false,\\n props: vec![ObjectPatProp::Rest(RestPat {\\n span,\\n dot3_token: span,\\n arg: Box::new(Pat::Ident(Ident::new(\"a34\".into(), span).into())),\\n type_ann: None\\n })],\\n type_ann: None,\\n })\\n .into(),\\n body: BlockStmt {\\n span,\\n stmts: vec![]\\n }\\n }),\\n finalizer: None\\n })\\n );\\n }\\n\\n #[test]\\n fn throw_this() {\\n assert_eq_ignore_span!(\\n stmt(\"throw this\"),\\n Stmt::Throw(ThrowStmt {\\n span,\\n arg: expr(\"this\"),\\n })\\n )\\n }\\n\\n #[test]\\n fn await_for_of() {\\n assert_eq_ignore_span!(\\n stmt(\"for await (const a of b) ;\"),\\n Stmt::ForOf(ForOfStmt {\\n span,\\n await_token: Some(span),\\n left: VarDeclOrPat::VarDecl(VarDecl {\\n span,\\n kind: VarDeclKind::Const,\\n decls: vec![VarDeclarator {\\n span,\\n init: None,\\n name: Pat::Ident(Ident::new(\"a\".into(), span).into()),\\n definite: false,\\n }],\\n declare: false,\\n }),\\n right: Box::new(Expr::Ident(Ident::new(\"b\".into(), span))),\\n\\n body: Box::new(Stmt::Empty(EmptyStmt { span })),\\n })\\n )\\n }\\n\\n #[test]\\n fn no_empty_without_semi() {\\n assert_eq_ignore_span!(\\n stmt(\"(function foo() { return 1 })\"),\\n stmt(\\n \"(function foo () {\\n return 1\\n })\"\\n )\\n );\\n\\n assert_eq_ignore_span!(\\n stmt(\"{ 1; }\"),\\n Stmt::Block(BlockStmt {\\n span,\\n stmts: vec![stmt(\"1\")],\\n })\\n );\\n }\\n\\n #[test]\\n fn if_else() {\\n assert_eq_ignore_span!(\\n stmt(\"if (a) b; else c\"),\\n Stmt::If(IfStmt {\\n span,\\n test: expr(\"a\"),\\n cons: Box::new(stmt(\"b;\")),\\n alt: Some(Box::new(stmt(\"c\"))),\\n })\\n );\\n }\\n\\n #[test]\\n fn class_decorator() {\\n assert_eq_ignore_span!(\\n test_parser(\\n \"\\n @decorator\\n @dec2\\n class Foo {}\\n \",\\n Syntax::Es(EsConfig {\\n decorators: true,\\n ..Default::default()\\n }),\\n |p| p.parse_stmt_list_item(true),\\n ),\\n Stmt::Decl(Decl::Class(ClassDecl {\\n ident: Ident::new(\"Foo\".into(), span),\\n class: Class {\\n span,\\n decorators: vec![\\n Decorator {\\n span,\\n expr: expr(\"decorator\")\\n },\\n Decorator {\\n span,\\n expr: expr(\"dec2\")\\n }\\n ],\\n super_class: None,\\n implements: vec![],\\n body: vec![],\\n is_abstract: false,\\n super_type_params: None,\\n type_params: None,\\n },\\n declare: false,\\n }))\\n );\\n }\\n\\n #[test]\\n fn example() {\\n let src = r#\"\\nimport React from \\'react\\'\\nimport ReactDOM from \\'react-dom\\'\\n\\nfunction App() {\\n return

JSX is working!

\\n}\\n\\nReactDOM.render(, document.getElementById(\\'root\\'))\\n\\n\"#;\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n jsx: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn ice() {\\n let src = r#\"import React from \"react\"\\n\\nfunction App() {\\n return

works

\\n}\\n\\nexport default App\"#;\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n jsx: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn export_default() {\\n let src = \"export v, { x, y as w } from \\'mod\\';\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n export_default_from: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn export_default_2() {\\n let src = \"export foo from \\'bar\\';\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n export_default_from: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn export_default_3() {\\n let src = \"export default from \\'bar\\';\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n export_default_from: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn export_default_4() {\\n let src = \"export default, {foo} from \\'bar\\';\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n export_default_from: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn shebang_01() {\\n let src = \"#!/usr/bin/env node\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn shebang_02() {\\n let src = \"#!/usr/bin/env node\\nlet x = 4\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn empty() {\\n test_parser(\\n \"\",\\n Syntax::Es(EsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_226() {\\n test_parser(\\n \"export * as Foo from \\'bar\\';\",\\n Syntax::Es(EsConfig {\\n export_default_from: true,\\n export_namespace_from: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_257_var() {\\n test_parser(\\n \"\\nexport default function waitUntil(callback, options = {}) {\\n var timeout = \\'timeout\\' in options ? options.timeout : 1000;\\n}\",\\n Default::default(),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_257_let() {\\n test_parser(\\n \"\\nexport default function waitUntil(callback, options = {}) {\\n let timeout = \\'timeout\\' in options ? options.timeout : 1000;\\n}\",\\n Default::default(),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_269() {\\n test_parser(\\n \";(function() {})(window, window.lib || (window.lib = {}))\",\\n Default::default(),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_319_2() {\\n module_item(\\n \"export default obj({\\n async f() {\\n await g();\\n }\\n});\",\\n );\\n }\\n\\n #[test]\\n fn issue_340_fn() {\\n test_parser(\"export default function(){};\", Default::default(), |p| {\\n p.parse_module()\\n });\\n }\\n\\n #[test]\\n fn issue_340_async_fn() {\\n test_parser(\\n \"export default async function(){};\",\\n Default::default(),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_340_generator_fn() {\\n test_parser(\"export default function*(){};\", Default::default(), |p| {\\n p.parse_module()\\n });\\n }\\n\\n #[test]\\n fn issue_340_class() {\\n test_parser(\"export default class {};\", Default::default(), |p| {\\n p.parse_module()\\n });\\n }\\n\\n #[test]\\n fn issue_360() {\\n test_parser(\\n \"var IS_IE11 = !global.ActiveXObject && \\'ActiveXObject\\' in global;\",\\n Default::default(),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_380_1() {\\n test_parser(\\n \"import(filePath).then(bar => {})\",\\n Syntax::Es(EsConfig {\\n dynamic_import: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_380_2() {\\n test_parser(\\n \"class Foo {\\n componentDidMount() {\\n const filePath = \\'../foo/bar\\'\\n import(filePath).then(bar => {})\\n }\\n }\",\\n Syntax::Es(EsConfig {\\n dynamic_import: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_411() {\\n test_parser(\\n \"try {\\n} catch {}\",\\n Syntax::Es(EsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn top_level_await() {\\n test_parser(\\n \"await foo\",\\n Syntax::Es(EsConfig {\\n top_level_await: true,\\n ..Default::default()\\n }),\\n |p| p.parse_module(),\\n );\\n }\\n\\n #[test]\\n fn issue_856() {\\n let c = SingleThreadedComments::default();\\n let s = \"class Foo {\\n static _extensions: {\\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\\n [key: string]: (module: Module, filename: string) => any;\\n } = Object.create(null);\\n}\\n\";\\n let _ = test_parser_comment(\\n &c,\\n s,\\n Syntax::Typescript(TsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_typescript_module(),\\n );\\n\\n let (leading, trailing) = c.take_all();\\n assert!(trailing.borrow().is_empty());\\n assert_eq!(leading.borrow().len(), 1);\\n }\\n\\n #[test]\\n fn issue_856_2() {\\n let c = SingleThreadedComments::default();\\n let s = \"type ConsoleExamineFunc = (\\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\\n csl: any,\\n out: StringBuffer,\\n err?: StringBuffer,\\n both?: StringBuffer\\n) => void;\";\\n\\n let _ = test_parser_comment(\\n &c,\\n s,\\n Syntax::Typescript(TsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_typescript_module(),\\n );\\n\\n let (leading, trailing) = c.take_all();\\n assert!(trailing.borrow().is_empty());\\n assert_eq!(leading.borrow().len(), 1);\\n }\\n\\n #[test]\\n fn issue_856_3() {\\n let c = SingleThreadedComments::default();\\n let s = \"type RequireWrapper = (\\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\\n exports: any,\\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\\n require: any,\\n module: Module,\\n __filename: string,\\n __dirname: string\\n) => void;\";\\n\\n let _ = test_parser_comment(\\n &c,\\n s,\\n Syntax::Typescript(TsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_typescript_module(),\\n );\\n\\n let (leading, trailing) = c.take_all();\\n assert!(trailing.borrow().is_empty());\\n assert_eq!(leading.borrow().len(), 2);\\n }\\n\\n #[test]\\n fn issue_856_4() {\\n let c = SingleThreadedComments::default();\\n let s = \"const _extensions: {\\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\\n [key: string]: (module: Module, filename: string) => any;\\n } = Object.create(null);\";\\n\\n let _ = test_parser_comment(\\n &c,\\n s,\\n Syntax::Typescript(TsConfig {\\n ..Default::default()\\n }),\\n |p| p.parse_typescript_module(),\\n );\\n\\n let (leading, trailing) = c.take_all();\\n assert!(trailing.borrow().is_empty());\\n assert_eq!(leading.borrow().len(), 1);\\n }\\n fn parse_for_head(str: &\\'static str) -> ForHead {\\n test_parser(str, Syntax::default(), |p| p.parse_for_head())\\n }\\n\\n #[test]\\n fn for_array_binding_pattern() {\\n match parse_for_head(\"let [, , t] = simple_array; t < 10; t++\") {\\n ForHead::For { init: Some(v), .. } => assert_eq_ignore_span!(\\n v,\\n VarDeclOrExpr::VarDecl(VarDecl {\\n span,\\n declare: false,\\n kind: VarDeclKind::Let,\\n decls: vec![VarDeclarator {\\n span,\\n name: Pat::Array(ArrayPat {\\n span,\\n type_ann: None,\\n optional: false,\\n elems: vec![\\n None,\\n None,\\n Some(Pat::Ident(Ident::new(\"t\".into(), span).into()))\\n ]\\n }),\\n init: Some(Box::new(Expr::Ident(Ident::new(\\n \"simple_array\".into(),\\n span\\n )))),\\n definite: false\\n }]\\n })\\n ),\\n _ => assert!(false),\\n }\\n }\\n #[test]\\n fn for_object_binding_pattern() {\\n match parse_for_head(\"let {num} = obj; num < 11; num++\") {\\n ForHead::For { init: Some(v), .. } => assert_eq_ignore_span!(\\n v,\\n VarDeclOrExpr::VarDecl(VarDecl {\\n span,\\n declare: false,\\n kind: VarDeclKind::Let,\\n decls: vec![VarDeclarator {\\n span,\\n name: Pat::Object(ObjectPat {\\n optional: false,\\n type_ann: None,\\n span,\\n props: vec![ObjectPatProp::Assign(AssignPatProp {\\n span,\\n key: Ident::new(\"num\".into(), span),\\n value: None\\n })]\\n }),\\n init: Some(Box::new(Expr::Ident(Ident::new(\"obj\".into(), span)))),\\n definite: false\\n }]\\n })\\n ),\\n _ => assert!(false),\\n }\\n }\\n\\n #[test]\\n #[should_panic(expected = \"\\'import.meta\\' cannot be used outside of module code.\")]\\n fn import_meta_in_script() {\\n let src = \"const foo = import.meta.url;\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n import_meta: true,\\n ..Default::default()\\n }),\\n |p| p.parse_script(),\\n );\\n }\\n\\n #[test]\\n fn import_meta_in_program() {\\n let src = \"const foo = import.meta.url;\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n import_meta: true,\\n ..Default::default()\\n }),\\n |p| p.parse_program(),\\n );\\n }\\n\\n #[test]\\n #[should_panic(expected = \"\\'import\\', and \\'export\\' cannot be used outside of module code\")]\\n fn import_statement_in_script() {\\n let src = \"import \\'foo\\';\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n dynamic_import: true,\\n ..Default::default()\\n }),\\n |p| p.parse_script(),\\n );\\n }\\n\\n #[test]\\n #[should_panic(expected = \"top level await is only allowed in module\")]\\n fn top_level_await_in_script() {\\n let src = \"await promise\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n top_level_await: true,\\n ..Default::default()\\n }),\\n |p| p.parse_script(),\\n );\\n }\\n\\n #[test]\\n fn top_level_await_in_program() {\\n let src = \"await promise\";\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n top_level_await: true,\\n ..Default::default()\\n }),\\n |p| p.parse_program(),\\n );\\n }\\n\\n #[test]\\n #[should_panic(expected = \"await isn\\'t allowed in non-async function\")]\\n fn await_in_function_in_module() {\\n let src = \"function foo (p) { await p; }\";\\n test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());\\n }\\n\\n #[test]\\n #[should_panic(expected = \"await isn\\'t allowed in non-async function\")]\\n fn await_in_function_in_script() {\\n let src = \"function foo (p) { await p; }\";\\n test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());\\n }\\n\\n #[test]\\n #[should_panic(expected = \"await isn\\'t allowed in non-async function\")]\\n fn await_in_function_in_program() {\\n let src = \"function foo (p) { await p; }\";\\n test_parser(src, Syntax::Es(Default::default()), |p| p.parse_program());\\n }\\n\\n #[test]\\n fn top_level_await_in_block() {\\n let src = \"if (true) { await promise; }\";\\n test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());\\n }\\n\\n #[test]\\n fn class_static_blocks() {\\n let src = \"class Foo { static { 1 + 1; } }\";\\n assert_eq_ignore_span!(\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n static_blocks: true,\\n ..Default::default()\\n }),\\n |p| p.parse_expr()\\n ),\\n Box::new(Expr::Class(ClassExpr {\\n ident: Some(Ident {\\n span,\\n sym: \"Foo\".into(),\\n optional: false,\\n }),\\n class: Class {\\n span,\\n decorators: Vec::new(),\\n super_class: None,\\n type_params: None,\\n super_type_params: None,\\n is_abstract: false,\\n implements: Vec::new(),\\n body: vec!(ClassMember::StaticBlock(StaticBlock {\\n span,\\n body: BlockStmt {\\n span,\\n stmts: vec!(stmt(\"1 + 1;\")),\\n }\\n }))\\n }\\n }))\\n );\\n }\\n\\n #[test]\\n fn multiple_class_static_blocks() {\\n let src = \"class Foo { static { 1 + 1; } static { 1 + 1; } }\";\\n assert_eq_ignore_span!(\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n static_blocks: true,\\n ..Default::default()\\n }),\\n |p| p.parse_expr()\\n ),\\n Box::new(Expr::Class(ClassExpr {\\n ident: Some(Ident {\\n span,\\n sym: \"Foo\".into(),\\n optional: false,\\n }),\\n class: Class {\\n span,\\n decorators: Vec::new(),\\n super_class: None,\\n type_params: None,\\n super_type_params: None,\\n is_abstract: false,\\n implements: Vec::new(),\\n body: vec!(\\n ClassMember::StaticBlock(StaticBlock {\\n span,\\n body: BlockStmt {\\n span,\\n stmts: vec!(stmt(\"1 + 1;\")),\\n },\\n }),\\n ClassMember::StaticBlock(StaticBlock {\\n span,\\n body: BlockStmt {\\n span,\\n stmts: vec!(stmt(\"1 + 1;\")),\\n },\\n })\\n )\\n }\\n }))\\n );\\n }\\n\\n #[test]\\n fn class_static_blocks_with_line_breaks_01() {\\n let src = \"class Foo {\\n static\\n {\\n 1 + 1;\\n }\\n }\";\\n assert_eq_ignore_span!(\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n static_blocks: true,\\n ..Default::default()\\n }),\\n |p| p.parse_expr()\\n ),\\n Box::new(Expr::Class(ClassExpr {\\n ident: Some(Ident {\\n span,\\n sym: \"Foo\".into(),\\n optional: false,\\n }),\\n class: Class {\\n span,\\n decorators: Vec::new(),\\n super_class: None,\\n type_params: None,\\n super_type_params: None,\\n is_abstract: false,\\n implements: Vec::new(),\\n body: vec!(ClassMember::StaticBlock(StaticBlock {\\n span,\\n body: BlockStmt {\\n span,\\n stmts: vec!(stmt(\"1 + 1;\")),\\n }\\n }))\\n }\\n }))\\n );\\n }\\n\\n #[test]\\n fn class_static_blocks_with_line_breaks_02() {\\n let src = \"class Foo {\\n static\\n {}\\n }\";\\n assert_eq_ignore_span!(\\n test_parser(\\n src,\\n Syntax::Es(EsConfig {\\n static_blocks: true,\\n ..Default::default()\\n }),\\n |p| p.parse_expr()\\n ),\\n Box::new(Expr::Class(ClassExpr {\\n ident: Some(Ident {\\n span,\\n sym: \"Foo\".into(),\\n optional: false,\\n }),\\n class: Class {\\n span,\\n decorators: Vec::new(),\\n super_class: None,\\n type_params: None,\\n super_type_params: None,\\n is_abstract: false,\\n implements: Vec::new(),\\n body: vec!(ClassMember::StaticBlock(StaticBlock {\\n span,\\n body: BlockStmt {\\n span,\\n stmts: Vec::new(),\\n }\\n }))\\n }\\n }))\\n );\\n }\\n\\n #[test]\\n fn class_static_blocks_in_ts() {\\n let src = \"class Foo { static { 1 + 1 }; }\";\\n test_parser(src, Syntax::Typescript(Default::default()), |p| {\\n p.parse_expr()\\n });\\n }\\n\\n #[test]\\n fn class_static_blocks_with_line_breaks_in_ts_01() {\\n let src = \"class Foo {\\n static\\n {\\n 1 + 1;\\n }\\n }\";\\n test_parser(src, Syntax::Typescript(Default::default()), |p| {\\n p.parse_expr()\\n });\\n }\\n\\n #[test]\\n fn class_static_blocks_with_line_breaks_in_ts_02() {\\n let src = \"class Foo {\\n static\\n {}\\n }\";\\n test_parser(src, Syntax::Typescript(Default::default()), |p| {\\n p.parse_expr()\\n });\\n }\\n\\n #[test]\\n #[should_panic(expected = \"Modifiers cannot appear here\")]\\n fn class_static_blocks_in_ts_with_invalid_modifier_01() {\\n let src = \"class Foo { abstract static { 1 + 1 }; }\";\\n test_parser(src, Syntax::Typescript(Default::default()), |p| {\\n p.parse_expr()\\n });\\n }\\n\\n #[test]\\n #[should_panic(expected = \"Modifiers cannot appear here\")]\\n fn class_static_blocks_in_ts_with_invalid_modifier_02() {\\n let src = \"class Foo { static static { 1 + 1 }; }\";\\n test_parser(src, Syntax::Typescript(Default::default()), |p| {\\n p.parse_expr()\\n });\\n }\\n\\n #[test]\\n #[should_panic(expected = \"Modifiers cannot appear here\")]\\n fn class_static_blocks_in_ts_with_invalid_modifier_03() {\\n let src = \"class Foo { declare static { 1 + 1 }; }\";\\n test_parser(src, Syntax::Typescript(Default::default()), |p| {\\n p.parse_expr()\\n });\\n }\\n\\n #[test]\\n #[should_panic(expected = \"Modifiers cannot appear here\")]\\n fn class_static_blocks_in_ts_with_invalid_modifier_04() {\\n let src = \"class Foo { private static { 1 + 1 }; }\";\\n test_parser(src, Syntax::Typescript(Default::default()), |p| {\\n p.parse_expr()\\n });\\n }\\n}\\n',\n", + " 'content_id': '6195dc2cb6ab3ad0694e47619fef487d5e7473a5',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/parser/src/parser/stmt.rs',\n", + " 'size': 62486,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.48075189906012616,\n", + " 'avg_line_length': 30.70204081632653,\n", + " 'blob_id': '102f858e6db927f44bf098f6d7e76d55c710faed',\n", + " 'content': 'use std::collections::hash_map::Entry;\\n\\nuse super::{ScopeDataLike, Storage, VarDataLike};\\nuse crate::analyzer::{ctx::Ctx, ProgramData, ScopeData, ScopeKind, VarUsageInfo};\\nuse rustc_hash::FxHashSet;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\n\\nimpl Storage for ProgramData {\\n type ScopeData = ScopeData;\\n type VarData = VarUsageInfo;\\n\\n fn scope(&mut self, ctxt: swc_common::SyntaxContext) -> &mut Self::ScopeData {\\n self.scopes.entry(ctxt).or_default()\\n }\\n\\n fn top_scope(&mut self) -> &mut Self::ScopeData {\\n &mut self.top\\n }\\n\\n fn var_or_default(&mut self, id: Id) -> &mut Self::VarData {\\n self.vars.entry(id).or_default()\\n }\\n\\n fn merge(&mut self, kind: ScopeKind, child: Self) {\\n for (ctxt, scope) in child.scopes {\\n let to = self.scopes.entry(ctxt).or_default();\\n self.top.merge(scope.clone(), true);\\n\\n to.merge(scope, false);\\n }\\n\\n for (id, mut var_info) in child.vars {\\n // tracing::trace!(\"merge({:?},{}{:?})\", kind, id.0, id.1);\\n match self.vars.entry(id) {\\n Entry::Occupied(mut e) => {\\n e.get_mut().inline_prevented |= var_info.inline_prevented;\\n\\n e.get_mut().ref_count += var_info.ref_count;\\n e.get_mut().cond_init |= var_info.cond_init;\\n\\n e.get_mut().reassigned |= var_info.reassigned;\\n e.get_mut().mutated |= var_info.mutated;\\n\\n e.get_mut().has_property_access |= var_info.has_property_access;\\n e.get_mut().exported |= var_info.exported;\\n\\n e.get_mut().declared |= var_info.declared;\\n e.get_mut().declared_count += var_info.declared_count;\\n e.get_mut().declared_as_fn_param |= var_info.declared_as_fn_param;\\n e.get_mut().declared_as_fn_expr |= var_info.declared_as_fn_expr;\\n\\n // If a var is registered at a parent scope, it means that it\\'s delcared before\\n // usages.\\n //\\n // e.get_mut().used_above_decl |= var_info.used_above_decl;\\n e.get_mut().used_in_loop |= var_info.used_in_loop;\\n e.get_mut().assign_count += var_info.assign_count;\\n e.get_mut().mutation_by_call_count += var_info.mutation_by_call_count;\\n e.get_mut().usage_count += var_info.usage_count;\\n\\n e.get_mut().declared_as_catch_param |= var_info.declared_as_catch_param;\\n\\n e.get_mut().infects.extend(var_info.infects);\\n\\n e.get_mut().no_side_effect_for_member_access =\\n e.get_mut().no_side_effect_for_member_access\\n && var_info.no_side_effect_for_member_access;\\n\\n e.get_mut().used_as_callee |= var_info.used_as_callee;\\n\\n match kind {\\n ScopeKind::Fn => {\\n e.get_mut().is_fn_local = false;\\n e.get_mut().used_by_nested_fn = true;\\n }\\n ScopeKind::Block => {\\n if var_info.used_by_nested_fn {\\n e.get_mut().is_fn_local = false;\\n e.get_mut().used_by_nested_fn = true;\\n }\\n }\\n }\\n }\\n Entry::Vacant(e) => {\\n match kind {\\n ScopeKind::Fn => {\\n var_info.used_by_nested_fn = true;\\n }\\n ScopeKind::Block => {}\\n }\\n e.insert(var_info);\\n }\\n }\\n }\\n }\\n\\n fn report_usage(&mut self, ctx: Ctx, i: &Ident, is_assign: bool) {\\n self.report(i.to_id(), ctx, is_assign, &mut Default::default());\\n }\\n\\n fn declare_decl(\\n &mut self,\\n ctx: Ctx,\\n i: &Ident,\\n has_init: bool,\\n kind: Option,\\n ) -> &mut VarUsageInfo {\\n // tracing::trace!(\"declare_decl({}{:?})\", i.sym, i.span.ctxt);\\n\\n let v = self\\n .vars\\n .entry(i.to_id())\\n .and_modify(|v| {\\n if has_init && v.declared {\\n v.mutated = true;\\n v.reassigned = true;\\n v.assign_count += 1;\\n }\\n\\n if v.used_by_nested_fn {\\n v.is_fn_local = false;\\n }\\n })\\n .or_insert_with(|| VarUsageInfo {\\n is_fn_local: true,\\n var_kind: kind,\\n var_initialized: has_init,\\n no_side_effect_for_member_access: ctx\\n .in_var_decl_with_no_side_effect_for_member_access,\\n\\n ..Default::default()\\n });\\n\\n v.declared_count += 1;\\n v.declared = true;\\n if ctx.in_cond && has_init {\\n v.cond_init = true;\\n }\\n v.declared_as_catch_param |= ctx.in_catch_param;\\n\\n v\\n }\\n}\\n\\nimpl ScopeDataLike for ScopeData {\\n fn add_declared_symbol(&mut self, _: &Ident) {}\\n\\n fn merge(&mut self, other: Self, _: bool) {\\n self.has_with_stmt |= other.has_with_stmt;\\n self.has_eval_call |= other.has_eval_call;\\n }\\n\\n fn mark_eval_called(&mut self) {\\n self.has_eval_call = true;\\n }\\n\\n fn mark_with_stmt(&mut self) {\\n self.has_with_stmt = true;\\n }\\n}\\n\\nimpl ProgramData {\\n fn report(&mut self, i: Id, ctx: Ctx, is_modify: bool, dejavu: &mut FxHashSet) {\\n // tracing::trace!(\"report({}{:?})\", i.0, i.1);\\n\\n let is_first = dejavu.is_empty();\\n\\n if !dejavu.insert(i.clone()) {\\n return;\\n }\\n\\n let e = self.vars.entry(i.clone()).or_insert_with(|| {\\n // tracing::trace!(\"insert({}{:?})\", i.0, i.1);\\n\\n VarUsageInfo {\\n is_fn_local: true,\\n used_above_decl: true,\\n ..Default::default()\\n }\\n });\\n\\n e.inline_prevented |= ctx.inline_prevented;\\n\\n if is_first {\\n e.ref_count += 1;\\n }\\n e.reassigned |= is_first && is_modify && ctx.is_exact_reassignment;\\n // Passing object as a argument is possibly modification.\\n e.mutated |= is_modify || (ctx.in_call_arg && ctx.is_exact_arg);\\n e.used_in_loop |= ctx.in_loop;\\n\\n if is_modify && ctx.is_exact_reassignment {\\n e.assign_count += 1;\\n\\n for other in e.infects.clone() {\\n self.report(other, ctx, true, dejavu)\\n }\\n } else {\\n if ctx.in_call_arg && ctx.is_exact_arg {\\n e.mutation_by_call_count += 1;\\n }\\n\\n e.usage_count += 1;\\n }\\n }\\n}\\n\\nimpl VarDataLike for VarUsageInfo {\\n fn mark_declared_as_fn_param(&mut self) {\\n self.declared_as_fn_param = true;\\n }\\n\\n fn mark_declared_as_fn_expr(&mut self) {\\n self.declared_as_fn_expr = true;\\n }\\n\\n fn mark_has_property_access(&mut self) {\\n self.has_property_access = true;\\n }\\n\\n fn mark_has_property_mutation(&mut self) {\\n self.has_property_mutation = true;\\n }\\n\\n fn add_accessed_property(&mut self, name: swc_atoms::JsWord) {\\n self.accessed_props.insert(name);\\n }\\n\\n fn mark_mutated(&mut self) {\\n self.mutated = true;\\n }\\n\\n fn mark_reassigned(&mut self) {\\n self.reassigned = true;\\n }\\n\\n fn add_infects(&mut self, other: Id) {\\n self.infects.push(other);\\n }\\n\\n fn mark_used_as_callee(&mut self) {\\n self.used_as_callee = true;\\n }\\n}\\n',\n", + " 'content_id': '8aae6b901b4471b2c4a0690adc7702337b91d085',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/minifier/src/analyzer/storage/normal.rs',\n", + " 'size': 7767,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.32570032388203873,\n", + " 'avg_line_length': 41.10287081339713,\n", + " 'blob_id': '41f0a45765121e84f7725792ce612360e3c48c3c',\n", + " 'content': 'use std::cell::{Ref, RefCell, RefMut};\\n\\nuse self::config::BuiltConfig;\\npub use self::config::Config;\\nuse super::util::{\\n self, define_es_module, define_property, has_use_strict, initialize_to_undefined,\\n local_name_for_src, make_descriptor, make_require_call, use_strict, Exports, ModulePass, Scope,\\n};\\nuse crate::path::{ImportResolver, NoopImportResolver};\\nuse rustc_hash::FxHashSet;\\nuse swc_atoms::js_word;\\nuse swc_common::{sync::Lrc, FileName, Mark, SourceMap, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::helper;\\nuse swc_ecma_utils::{\\n member_expr, prepend_stmts, private_ident, quote_ident, quote_str, var::VarCollector,\\n DestructuringFinder, ExprFactory,\\n};\\nuse swc_ecma_visit::{noop_fold_type, Fold, FoldWith, VisitWith};\\n\\nmod config;\\n\\npub fn umd(cm: Lrc, root_mark: Mark, config: Config) -> impl Fold {\\n Umd {\\n config: config.build(cm.clone()),\\n root_mark,\\n cm,\\n\\n in_top_level: Default::default(),\\n scope: RefCell::new(Default::default()),\\n exports: Default::default(),\\n\\n resolver: None::<(NoopImportResolver, _)>,\\n }\\n}\\n\\npub fn umd_with_resolver(\\n resolver: R,\\n base: FileName,\\n cm: Lrc,\\n root_mark: Mark,\\n config: Config,\\n) -> impl Fold\\nwhere\\n R: ImportResolver,\\n{\\n Umd {\\n config: config.build(cm.clone()),\\n root_mark,\\n cm,\\n\\n in_top_level: Default::default(),\\n scope: Default::default(),\\n exports: Default::default(),\\n\\n resolver: Some((resolver, base)),\\n }\\n}\\n\\nstruct Umd\\nwhere\\n R: ImportResolver,\\n{\\n cm: Lrc,\\n root_mark: Mark,\\n in_top_level: bool,\\n config: BuiltConfig,\\n scope: RefCell,\\n exports: Exports,\\n\\n resolver: Option<(R, FileName)>,\\n}\\n\\nimpl Fold for Umd\\nwhere\\n R: ImportResolver,\\n{\\n noop_fold_type!();\\n\\n fn fold_expr(&mut self, expr: Expr) -> Expr {\\n let exports = self.exports.0.clone();\\n let top_level = self.in_top_level;\\n\\n Scope::fold_expr(self, exports, top_level, expr)\\n }\\n\\n fn fold_module(&mut self, module: Module) -> Module {\\n self.in_top_level = true;\\n\\n let filename = self.cm.span_to_filename(module.span);\\n\\n let items = module.body;\\n\\n // Inserted after initializing exported names to undefined.\\n let mut extra_stmts = vec![];\\n let mut stmts = Vec::with_capacity(items.len() + 2);\\n if self.config.config.strict_mode && !has_use_strict(&items) {\\n stmts.push(use_strict());\\n }\\n\\n let mut exports = vec![];\\n let mut initialized = FxHashSet::default();\\n let mut export_alls = vec![];\\n let mut emitted_esmodule = false;\\n let mut has_export = false;\\n let exports_ident = self.exports.0.clone();\\n\\n // Process items\\n for item in items {\\n let decl = match item {\\n ModuleItem::Stmt(stmt) => {\\n extra_stmts.push(stmt.fold_with(self));\\n continue;\\n }\\n ModuleItem::ModuleDecl(decl) => decl,\\n };\\n\\n match decl {\\n ModuleDecl::Import(import) => self.scope.borrow_mut().insert_import(import),\\n\\n ModuleDecl::ExportAll(..)\\n | ModuleDecl::ExportDecl(..)\\n | ModuleDecl::ExportDefaultDecl(..)\\n | ModuleDecl::ExportDefaultExpr(..)\\n | ModuleDecl::ExportNamed(..) => {\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n has_export = true;\\n if !self.config.config.strict && !emitted_esmodule {\\n emitted_esmodule = true;\\n stmts.push(define_es_module(exports_ident.clone()));\\n }\\n\\n macro_rules! init_export {\\n (\"default\") => {{\\n init_export!(js_word!(\"default\"))\\n }};\\n ($name:expr) => {{\\n exports.push($name.clone());\\n initialized.insert($name.clone());\\n }};\\n }\\n match decl {\\n // Function declaration cannot throw an error.\\n ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl: DefaultDecl::Fn(..),\\n ..\\n }) => {\\n // initialized.insert(js_word!(\"default\"));\\n }\\n\\n ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {\\n decl: DefaultDecl::TsInterfaceDecl(..),\\n ..\\n }) => {}\\n\\n ModuleDecl::ExportAll(ref export) => {\\n scope\\n .import_types\\n .entry(export.src.value.clone())\\n .and_modify(|v| *v = true);\\n }\\n\\n ModuleDecl::ExportDefaultDecl(..) | ModuleDecl::ExportDefaultExpr(..) => {\\n // TODO: Optimization (when expr cannot throw, `exports.default =\\n // void 0` is not required)\\n init_export!(\"default\")\\n }\\n _ => {}\\n }\\n drop(scope);\\n drop(scope_ref_mut);\\n\\n match decl {\\n ModuleDecl::ExportAll(export) => export_alls.push(export),\\n ModuleDecl::ExportDecl(ExportDecl {\\n decl: decl @ Decl::Class(..),\\n ..\\n })\\n | ModuleDecl::ExportDecl(ExportDecl {\\n decl: decl @ Decl::Fn(..),\\n ..\\n }) => {\\n let (ident, is_class) = match decl {\\n Decl::Class(ref c) => (c.ident.clone(), true),\\n Decl::Fn(ref f) => (f.ident.clone(), false),\\n _ => unreachable!(),\\n };\\n\\n //\\n extra_stmts.push(Stmt::Decl(decl.fold_with(self)));\\n\\n let append_to: &mut Vec<_> = if is_class {\\n &mut extra_stmts\\n } else {\\n // Function declaration cannot throw\\n &mut stmts\\n };\\n\\n append_to.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident.clone().make_member(ident.clone()),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n ModuleDecl::ExportDecl(ExportDecl {\\n decl: Decl::Var(var),\\n ..\\n }) => {\\n extra_stmts.push(Stmt::Decl(Decl::Var(var.clone().fold_with(self))));\\n\\n let scope = &mut *self.scope.borrow_mut();\\n var.decls.visit_with(\\n &Invalid { span: DUMMY_SP } as _,\\n &mut VarCollector {\\n to: &mut scope.declared_vars,\\n },\\n );\\n\\n let mut found: Vec = vec![];\\n for decl in var.decls {\\n let mut v = DestructuringFinder { found: &mut found };\\n decl.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n\\n for ident in found.drain(..) {\\n scope\\n .exported_vars\\n .entry((ident.sym.clone(), ident.span.ctxt()))\\n .or_default()\\n .push((ident.sym.clone(), ident.span.ctxt()));\\n init_export!(ident.sym);\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident.clone().make_member(ident.clone()),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n }\\n }\\n ModuleDecl::ExportDefaultDecl(decl) => match decl.decl {\\n DefaultDecl::Class(ClassExpr { ident, class }) => {\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_default\"));\\n\\n extra_stmts.push(Stmt::Decl(Decl::Class(ClassDecl {\\n ident: ident.clone(),\\n class,\\n declare: false,\\n })));\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident\\n .clone()\\n .make_member(quote_ident!(\"default\")),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n DefaultDecl::Fn(FnExpr { ident, function }) => {\\n let ident = ident.unwrap_or_else(|| private_ident!(\"_default\"));\\n\\n extra_stmts.push(Stmt::Decl(Decl::Fn(\\n FnDecl {\\n ident: ident.clone(),\\n function,\\n declare: false,\\n }\\n .fold_with(self),\\n )));\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident\\n .clone()\\n .make_member(quote_ident!(\"default\")),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n _ => {}\\n },\\n\\n ModuleDecl::ExportDefaultExpr(expr) => {\\n let ident = private_ident!(\"_default\");\\n\\n // We use extra statements because of the initialization\\n extra_stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(ident.clone().into()),\\n init: Some(expr.expr.fold_with(self)),\\n definite: false,\\n }],\\n declare: false,\\n })));\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident.clone().make_member(quote_ident!(\"default\")),\\n )),\\n op: op!(\"=\"),\\n right: Box::new(ident.into()),\\n }\\n .into_stmt(),\\n );\\n }\\n\\n // export { foo } from \\'foo\\';\\n ModuleDecl::ExportNamed(export) => {\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n let imported = export.src.clone().map(|src| {\\n scope.import_to_export(&src, !export.specifiers.is_empty())\\n });\\n drop(scope);\\n drop(scope_ref_mut);\\n\\n stmts.reserve(export.specifiers.len());\\n\\n for ExportNamedSpecifier { orig, exported, .. } in export\\n .specifiers\\n .into_iter()\\n .map(|e| match e {\\n ExportSpecifier::Named(e) => e,\\n ExportSpecifier::Default(..) => unreachable!(\\n \"export default from \\'foo\\'; should be removed by previous \\\\\\n pass\"\\n ),\\n ExportSpecifier::Namespace(..) => unreachable!(\\n \"export * as Foo from \\'foo\\'; should be removed by \\\\\\n previous pass\"\\n ),\\n })\\n .filter(|e| !e.is_type_only)\\n {\\n let is_import_default = orig.sym == js_word!(\"default\");\\n\\n let key = (orig.sym.clone(), orig.span.ctxt());\\n let mut scope_ref_mut = self.scope.borrow_mut();\\n let scope = &mut *scope_ref_mut;\\n if scope.declared_vars.contains(&key) {\\n scope.exported_vars.entry(key.clone()).or_default().push(\\n exported\\n .clone()\\n .map(|i| (i.sym.clone(), i.span.ctxt()))\\n .unwrap_or_else(|| {\\n (orig.sym.clone(), orig.span.ctxt())\\n }),\\n );\\n }\\n\\n if let Some(ref src) = export.src {\\n if is_import_default {\\n scope\\n .import_types\\n .entry(src.value.clone())\\n .or_insert(false);\\n }\\n }\\n drop(scope);\\n drop(scope_ref_mut);\\n\\n let value = match imported {\\n Some(ref imported) => Box::new(\\n imported.clone().unwrap().make_member(orig.clone()),\\n ),\\n None => Box::new(Expr::Ident(orig.clone()).fold_with(self)),\\n };\\n\\n // True if we are exporting our own stuff.\\n let is_value_ident = match *value {\\n Expr::Ident(..) => true,\\n _ => false,\\n };\\n\\n if is_value_ident {\\n let exported_symbol = exported\\n .as_ref()\\n .map(|e| e.sym.clone())\\n .unwrap_or_else(|| orig.sym.clone());\\n init_export!(exported_symbol);\\n\\n extra_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports_ident\\n .clone()\\n .make_member(exported.unwrap_or(orig)),\\n )),\\n op: op!(\"=\"),\\n right: value,\\n }\\n .into_stmt(),\\n );\\n } else {\\n stmts.push(\\n define_property(vec![\\n exports_ident.clone().as_arg(),\\n {\\n // export { foo }\\n // -> \\'foo\\'\\n\\n // export { foo as bar }\\n // -> \\'bar\\'\\n let i = exported.unwrap_or_else(|| orig);\\n Lit::Str(quote_str!(i.span, i.sym)).as_arg()\\n },\\n make_descriptor(value).as_arg(),\\n ])\\n .into_stmt(),\\n );\\n }\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n ModuleDecl::TsImportEquals(..)\\n | ModuleDecl::TsExportAssignment(..)\\n | ModuleDecl::TsNamespaceExport(..) => {}\\n }\\n }\\n\\n // ====================\\n // Handle imports\\n // ====================\\n\\n // Prepended to statements.\\n let mut import_stmts = vec![];\\n let mut define_deps_arg = ArrayLit {\\n span: DUMMY_SP,\\n elems: vec![],\\n };\\n\\n let scope = &mut *self.scope.borrow_mut();\\n let mut factory_params = Vec::with_capacity(scope.imports.len() + 1);\\n let mut factory_args = Vec::with_capacity(factory_params.capacity());\\n let mut global_factory_args = Vec::with_capacity(factory_params.capacity());\\n if has_export {\\n define_deps_arg\\n .elems\\n .push(Some(Lit::Str(quote_str!(\"exports\")).as_arg()));\\n factory_params.push(Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(exports_ident.clone().into()),\\n });\\n factory_args.push(quote_ident!(\"exports\").as_arg());\\n global_factory_args.push(member_expr!(DUMMY_SP, mod.exports).as_arg());\\n }\\n\\n // Used only if export * exists\\n let exported_names = {\\n if !export_alls.is_empty() && !exports.is_empty() {\\n let exported_names = private_ident!(\"_exportNames\");\\n stmts.push(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(exported_names.clone().into()),\\n init: Some(Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: exports\\n .into_iter()\\n .filter_map(|export| {\\n if export == js_word!(\"default\") {\\n return None;\\n }\\n\\n Some(PropOrSpread::Prop(Box::new(Prop::KeyValue(\\n KeyValueProp {\\n key: PropName::Ident(Ident::new(export, DUMMY_SP)),\\n value: Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n },\\n ))))\\n })\\n .collect(),\\n }))),\\n definite: false,\\n }],\\n declare: false,\\n })));\\n\\n Some(exported_names)\\n } else {\\n None\\n }\\n };\\n\\n for export in export_alls {\\n stmts.push(scope.handle_export_all(\\n exports_ident.clone(),\\n exported_names.clone(),\\n export,\\n ));\\n }\\n\\n if !initialized.is_empty() {\\n stmts.push(initialize_to_undefined(exports_ident, initialized).into_stmt());\\n }\\n\\n for (src, import) in scope.imports.drain(..) {\\n let global_ident = Ident::new(self.config.global_name(&src), DUMMY_SP);\\n let import = import.unwrap_or_else(|| {\\n (\\n local_name_for_src(&src),\\n DUMMY_SP.apply_mark(Mark::fresh(Mark::root())),\\n )\\n });\\n let ident = Ident::new(import.0.clone(), import.1);\\n\\n define_deps_arg\\n .elems\\n .push(Some(Lit::Str(quote_str!(src.clone())).as_arg()));\\n factory_params.push(Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(ident.clone().into()),\\n });\\n factory_args\\n .push(make_require_call(&self.resolver, self.root_mark, src.clone()).as_arg());\\n global_factory_args.push(quote_ident!(\"global\").make_member(global_ident).as_arg());\\n\\n {\\n // handle interop\\n let ty = scope.import_types.get(&src);\\n\\n match ty {\\n Some(&wildcard) => {\\n let imported = ident.clone();\\n\\n if !self.config.config.no_interop {\\n let right = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: if wildcard {\\n helper!(interop_require_wildcard, \"interopRequireWildcard\")\\n } else {\\n helper!(interop_require_default, \"interopRequireDefault\")\\n },\\n args: vec![imported.as_arg()],\\n type_args: Default::default(),\\n }));\\n\\n import_stmts.push(\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(\\n ident.clone().into(),\\n ))),\\n op: op!(\"=\"),\\n right,\\n }\\n .into_stmt(),\\n );\\n }\\n }\\n _ => {}\\n };\\n }\\n }\\n\\n prepend_stmts(&mut stmts, import_stmts.into_iter());\\n stmts.append(&mut extra_stmts);\\n\\n // ====================\\n // Emit\\n // ====================\\n\\n let helper_fn = Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n params: vec![\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"global\").into()),\\n },\\n Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(quote_ident!(\"factory\").into()),\\n },\\n ],\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: {\\n // typeof define === \\'function\\' && define.amd\\n let is_amd = Box::new(\\n UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"typeof\"),\\n arg: Box::new(Expr::Ident(quote_ident!(\"define\"))),\\n }\\n .make_eq(Lit::Str(quote_str!(\"function\")))\\n .make_bin(op!(\"&&\"), *member_expr!(DUMMY_SP, define.amd)),\\n );\\n\\n let is_common_js = Box::new(\\n UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"typeof\"),\\n arg: Box::new(Expr::Ident(quote_ident!(\"exports\"))),\\n }\\n .make_bin(op!(\"!==\"), Lit::Str(quote_str!(\"undefined\"))),\\n );\\n\\n vec![Stmt::If(IfStmt {\\n span: DUMMY_SP,\\n test: is_amd,\\n cons: Box::new(Stmt::Block(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![\\n // define([\\'foo\\'], factory)\\n CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"define\").as_callee(),\\n args: vec![\\n define_deps_arg.as_arg(),\\n quote_ident!(\"factory\").as_arg(),\\n ],\\n type_args: Default::default(),\\n }\\n .into_stmt(),\\n ],\\n })),\\n alt: Some(Box::new(Stmt::If(IfStmt {\\n span: DUMMY_SP,\\n test: is_common_js,\\n cons: Box::new(Stmt::Block(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![\\n // factory(require(\\'foo\\'))\\n CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"factory\").as_callee(),\\n args: factory_args,\\n type_args: Default::default(),\\n }\\n .into_stmt(),\\n ],\\n })),\\n alt: Some(Box::new(Stmt::Block(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: vec![VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(quote_ident!(\"mod\").into()),\\n init: Some(Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: vec![PropOrSpread::Prop(Box::new(\\n Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\\n \"exports\"\\n )),\\n value: Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: vec![],\\n })),\\n }),\\n ))],\\n }))),\\n definite: false,\\n }],\\n declare: false,\\n })),\\n CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(\"factory\").as_callee(),\\n args: global_factory_args,\\n type_args: Default::default(),\\n }\\n .into_stmt(),\\n {\\n let exported_name =\\n self.config.determine_export_name(filename);\\n\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n quote_ident!(\"global\").make_member(exported_name),\\n )),\\n op: op!(\"=\"),\\n right: member_expr!(DUMMY_SP,mod.exports),\\n }\\n .into_stmt()\\n },\\n ],\\n }))),\\n }))),\\n })]\\n },\\n }),\\n\\n return_type: Default::default(),\\n type_params: Default::default(),\\n };\\n\\n let factory_arg = FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n params: factory_params,\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts,\\n }),\\n\\n return_type: Default::default(),\\n type_params: Default::default(),\\n },\\n }\\n .as_arg();\\n\\n Module {\\n body: vec![CallExpr {\\n span: DUMMY_SP,\\n callee: FnExpr {\\n ident: None,\\n function: helper_fn,\\n }\\n .wrap_with_paren()\\n .as_callee(),\\n args: vec![ThisExpr { span: DUMMY_SP }.as_arg(), factory_arg],\\n type_args: Default::default(),\\n }\\n .into_stmt()\\n .into()],\\n ..module\\n }\\n }\\n\\n fn fold_prop(&mut self, p: Prop) -> Prop {\\n match p {\\n Prop::Shorthand(ident) => {\\n let top_level = self.in_top_level;\\n Scope::fold_shorthand_prop(self, top_level, ident)\\n }\\n\\n _ => p.fold_children_with(self),\\n }\\n }\\n\\n ///\\n /// - collects all declared variables for let and var.\\n fn fold_var_decl(&mut self, var: VarDecl) -> VarDecl {\\n if var.kind != VarDeclKind::Const {\\n var.decls.visit_with(\\n &Invalid { span: DUMMY_SP } as _,\\n &mut VarCollector {\\n to: &mut self.scope.borrow_mut().declared_vars,\\n },\\n );\\n }\\n\\n VarDecl {\\n decls: var.decls.fold_with(self),\\n ..var\\n }\\n }\\n\\n mark_as_nested!();\\n}\\n\\nimpl ModulePass for Umd\\nwhere\\n R: ImportResolver,\\n{\\n fn config(&self) -> &util::Config {\\n &self.config.config\\n }\\n\\n fn scope(&self) -> Ref {\\n self.scope.borrow()\\n }\\n\\n fn scope_mut(&mut self) -> RefMut {\\n self.scope.borrow_mut()\\n }\\n\\n /// ```js\\n /// exports === undefined ? (try_amd) : (try_common_js)\\n /// ```\\n fn make_dynamic_import(&mut self, span: swc_common::Span, args: Vec) -> Expr {\\n Expr::Cond(CondExpr {\\n span,\\n test: Box::new(quote_ident!(\"exports\").make_eq(quote_ident!(\"undefined\"))),\\n cons: Box::new(super::amd::handle_dynamic_import(span, args.clone())),\\n alt: Box::new(super::common_js::handle_dynamic_import(\\n span,\\n args,\\n !self.config.config.no_interop,\\n )),\\n })\\n }\\n}\\n',\n", + " 'content_id': '5bd453ff806787a35993305a701d0c56abab5b44',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/ecmascript/transforms/module/src/umd.rs',\n", + " 'size': 35198,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.40505363686104157,\n", + " 'avg_line_length': 34.250146113383984,\n", + " 'blob_id': 'ec49294e8967a2121fa165159ca5418215f7934e',\n", + " 'content': 'use super::{pat::PatType, util::ExprExt, *};\\nuse crate::{lexer::TokenContext, token::AssignOpToken};\\nuse either::Either;\\nuse swc_atoms::js_word;\\nuse swc_common::{ast_node, Spanned};\\n\\nmod ops;\\n#[cfg(test)]\\nmod tests;\\nmod verifier;\\n\\nimpl<\\'a, I: Tokens> Parser {\\n pub fn parse_expr(&mut self) -> PResult> {\\n trace_cur!(self, parse_expr);\\n\\n let expr = self.parse_assignment_expr()?;\\n let start = expr.span().lo();\\n\\n if is!(self, \\',\\') {\\n let mut exprs = vec![expr];\\n while eat!(self, \\',\\') {\\n exprs.push(self.parse_assignment_expr()?);\\n }\\n let end = exprs.last().unwrap().span().hi();\\n return Ok(Box::new(Expr::Seq(SeqExpr {\\n span: span!(self, start),\\n exprs,\\n })));\\n }\\n\\n Ok(expr)\\n }\\n\\n ///`parseMaybeAssign` (overridden)\\n pub(super) fn parse_assignment_expr(&mut self) -> PResult> {\\n trace_cur!(self, parse_assignment_expr);\\n\\n if self.input.syntax().typescript() {\\n // Note: When the JSX plugin is on, type assertions (` x`) aren\\'t valid\\n // syntax.\\n\\n if is!(self, JSXTagStart) {\\n let cur_context = self.input.token_context().current();\\n debug_assert_eq!(cur_context, Some(TokenContext::JSXOpeningTag));\\n // Only time j_oTag is pushed is right after j_expr.\\n debug_assert_eq!(\\n self.input.token_context().0[self.input.token_context().len() - 2],\\n TokenContext::JSXExpr\\n );\\n\\n let res = self.try_parse_ts(|p| p.parse_assignment_expr_base().map(Some));\\n if let Some(res) = res {\\n return Ok(res);\\n } else {\\n debug_assert_eq!(\\n self.input.token_context().current(),\\n Some(TokenContext::JSXOpeningTag)\\n );\\n self.input.token_context_mut().pop();\\n debug_assert_eq!(\\n self.input.token_context().current(),\\n Some(TokenContext::JSXExpr)\\n );\\n self.input.token_context_mut().pop();\\n }\\n }\\n }\\n\\n self.parse_assignment_expr_base()\\n }\\n\\n /// Parse an assignment expression. This includes applications of\\n /// operators like `+=`.\\n ///\\n /// `parseMaybeAssign`\\n fn parse_assignment_expr_base(&mut self) -> PResult> {\\n trace_cur!(self, parse_assignment_expr_base);\\n\\n if self.input.syntax().typescript()\\n && (is_one_of!(self, \\'<\\', JSXTagStart))\\n && (peeked_is!(self, IdentName) || peeked_is!(self, JSXName))\\n {\\n let ctx = Context {\\n is_direct_child_of_cond: false,\\n dont_store_comments: true,\\n ..self.ctx()\\n };\\n let res = self.with_ctx(ctx).try_parse_ts(|p| {\\n if is!(p, JSXTagStart) {\\n if let Some(TokenContext::JSXOpeningTag) = p.input.token_context().current() {\\n p.input.token_context_mut().pop();\\n\\n debug_assert_eq!(\\n p.input.token_context().current(),\\n Some(TokenContext::JSXExpr)\\n );\\n p.input.token_context_mut().pop();\\n }\\n }\\n\\n let type_parameters = p.parse_ts_type_params()?;\\n let mut arrow = p.parse_assignment_expr_base()?;\\n match *arrow {\\n Expr::Arrow(ArrowExpr {\\n ref mut span,\\n ref mut type_params,\\n ..\\n }) => {\\n *span = Span::new(type_parameters.span.lo, span.hi, Default::default());\\n *type_params = Some(type_parameters);\\n }\\n _ => unexpected!(p, \"(\"),\\n }\\n Ok(Some(arrow))\\n });\\n if let Some(res) = res {\\n return Ok(res);\\n }\\n }\\n\\n if self.ctx().in_generator && is!(self, \"yield\") {\\n return self.parse_yield_expr();\\n }\\n\\n self.state.potential_arrow_start = match *cur!(self, true)? {\\n Word(Word::Ident(..)) | tok!(\\'(\\') | tok!(\"yield\") => Some(cur_pos!(self)),\\n _ => None,\\n };\\n\\n let start = cur_pos!(self);\\n\\n // Try to parse conditional expression.\\n let cond = self.parse_cond_expr()?;\\n\\n return_if_arrow!(self, cond);\\n\\n match *cond {\\n // if cond is conditional expression but not left-hand-side expression,\\n // just return it.\\n Expr::Cond(..) | Expr::Bin(..) | Expr::Unary(..) | Expr::Update(..) => return Ok(cond),\\n _ => {}\\n }\\n\\n self.finish_assignment_expr(start, cond)\\n }\\n\\n fn finish_assignment_expr(&mut self, start: BytePos, cond: Box) -> PResult> {\\n trace_cur!(self, finish_assignment_expr);\\n\\n match cur!(self, false) {\\n Ok(&Token::AssignOp(op)) => {\\n let left = if op == AssignOpToken::Assign {\\n self.reparse_expr_as_pat(PatType::AssignPat, cond)\\n .map(Box::new)\\n .map(PatOrExpr::Pat)?\\n } else {\\n //It is an early Reference Error if IsValidSimpleAssignmentTarget of\\n // LeftHandSideExpression is false.\\n if !self.input.syntax().typescript()\\n && !cond.is_valid_simple_assignment_target(self.ctx().strict)\\n {\\n self.emit_err(cond.span(), SyntaxError::NotSimpleAssign)\\n }\\n let is_eval_or_arguments = match *cond {\\n Expr::Ident(ref i) => {\\n i.sym == js_word!(\"eval\") || i.sym == js_word!(\"arguments\")\\n }\\n _ => false,\\n };\\n if self.input.syntax().typescript() && is_eval_or_arguments {\\n self.emit_strict_mode_err(cond.span(), SyntaxError::TS1100);\\n }\\n\\n // TODO\\n PatOrExpr::Expr(cond)\\n };\\n\\n bump!(self);\\n let right = self.parse_assignment_expr()?;\\n Ok(Box::new(Expr::Assign(AssignExpr {\\n span: span!(self, start),\\n op,\\n // TODO:\\n left,\\n right,\\n })))\\n }\\n _ => Ok(cond),\\n }\\n }\\n\\n /// Spec: \\'ConditionalExpression\\'\\n fn parse_cond_expr(&mut self) -> PResult> {\\n trace_cur!(self, parse_cond_expr);\\n\\n let start = cur_pos!(self);\\n\\n let test = self.parse_bin_expr()?;\\n return_if_arrow!(self, test);\\n\\n if eat!(self, \\'?\\') {\\n let ctx = Context {\\n in_cond_expr: true,\\n is_direct_child_of_cond: true,\\n include_in_expr: true,\\n ..self.ctx()\\n };\\n let cons = self.with_ctx(ctx).parse_assignment_expr()?;\\n expect!(self, \\':\\');\\n let ctx = Context {\\n in_cond_expr: true,\\n is_direct_child_of_cond: true,\\n ..self.ctx()\\n };\\n let alt = self.with_ctx(ctx).parse_assignment_expr()?;\\n let span = Span::new(start, alt.span().hi(), Default::default());\\n Ok(Box::new(Expr::Cond(CondExpr {\\n span,\\n test,\\n cons,\\n alt,\\n })))\\n } else {\\n Ok(test)\\n }\\n }\\n\\n /// Parse a primary expression or arrow function\\n #[allow(clippy::cognitive_complexity)]\\n pub(super) fn parse_primary_expr(&mut self) -> PResult> {\\n trace_cur!(self, parse_primary_expr);\\n\\n let _ = self.input.cur();\\n let start = cur_pos!(self);\\n\\n let can_be_arrow = self\\n .state\\n .potential_arrow_start\\n .map(|s| s == start)\\n .unwrap_or(false);\\n\\n match self.input.cur() {\\n Some(tok) => match tok {\\n tok!(\"this\") => {\\n self.input.bump();\\n return Ok(Box::new(Expr::This(ThisExpr {\\n span: span!(self, start),\\n })));\\n }\\n\\n tok!(\"import\") => {\\n let import = self.parse_ident_name()?;\\n if self.input.syntax().import_meta() && is!(self, \\'.\\') {\\n self.state.found_module_item = true;\\n if !self.ctx().can_be_module {\\n let span = span!(self, start);\\n self.emit_err(span, SyntaxError::ImportMetaInScript);\\n }\\n return self\\n .parse_import_meta_prop(import)\\n .map(Expr::MetaProp)\\n .map(Box::new);\\n }\\n\\n return self.parse_dynamic_import(start, import);\\n }\\n\\n tok!(\"async\") => {\\n if peeked_is!(self, \"function\")\\n && !self.input.has_linebreak_between_cur_and_peeked()\\n {\\n // handle `async function` expression\\n return self.parse_async_fn_expr();\\n }\\n\\n if can_be_arrow && self.input.syntax().typescript() && peeked_is!(self, \\'<\\') {\\n // try parsing `async() => {}`\\n if let Some(res) = self.try_parse_ts(|p| {\\n let start = cur_pos!(p);\\n assert_and_bump!(p, \"async\");\\n p.try_parse_ts_generic_async_arrow_fn(start)\\n }) {\\n return Ok(Box::new(Expr::Arrow(res)));\\n }\\n }\\n\\n if can_be_arrow && peeked_is!(self, \\'(\\') {\\n expect!(self, \"async\");\\n let async_span = self.input.prev_span();\\n return self.parse_paren_expr_or_arrow_fn(can_be_arrow, Some(async_span));\\n }\\n }\\n\\n tok!(\\'[\\') => {\\n let ctx = Context {\\n is_direct_child_of_cond: false,\\n dont_parse_colon_as_type_ann: false,\\n ..self.ctx()\\n };\\n return self.with_ctx(ctx).parse_array_lit();\\n }\\n\\n tok!(\\'{\\') => {\\n return self.parse_object();\\n }\\n\\n // Handle FunctionExpression and GeneratorExpression\\n tok!(\"function\") => {\\n return self.parse_fn_expr();\\n }\\n\\n // Literals\\n tok!(\"null\")\\n | tok!(\"true\")\\n | tok!(\"false\")\\n | Token::Num(..)\\n | Token::BigInt(..)\\n | Token::Str { .. } => {\\n return Ok(Box::new(Expr::Lit(self.parse_lit()?)));\\n }\\n\\n // Regexp\\n Token::Regex(..) => match bump!(self) {\\n Token::Regex(exp, flags) => {\\n return Ok(Box::new(Expr::Lit(Lit::Regex(Regex {\\n span: span!(self, start),\\n exp,\\n flags,\\n }))));\\n }\\n _ => unreachable!(),\\n },\\n\\n tok!(\\'`\\') => {\\n // parse template literal\\n return Ok(Box::new(Expr::Tpl(self.parse_tpl()?)));\\n }\\n\\n tok!(\\'(\\') => {\\n return self.parse_paren_expr_or_arrow_fn(can_be_arrow, None);\\n }\\n\\n _ => {}\\n },\\n None => {}\\n }\\n\\n let decorators = self.parse_decorators(false)?;\\n\\n if is!(self, \"class\") {\\n return self.parse_class_expr(start, decorators);\\n }\\n\\n if is!(self, \"let\")\\n || (self.input.syntax().typescript() && is!(self, IdentName))\\n || is!(self, IdentRef)\\n {\\n // TODO: Handle [Yield, Await]\\n let id = self.parse_ident_name()?;\\n match id.sym {\\n // js_word!(\"eval\") | js_word!(\"arguments\") => {\\n // self.emit_err(id.span,\\n // SyntaxError::EvalAndArgumentsInStrict)\\n // }\\n js_word!(\"yield\")\\n | js_word!(\"static\")\\n | js_word!(\"implements\")\\n | js_word!(\"let\")\\n | js_word!(\"package\")\\n | js_word!(\"private\")\\n | js_word!(\"protected\")\\n | js_word!(\"public\") => {\\n self.emit_strict_mode_err(\\n self.input.prev_span(),\\n SyntaxError::InvalidIdentInStrict,\\n );\\n }\\n _ => {}\\n }\\n\\n if can_be_arrow && id.sym == js_word!(\"async\") && is!(self, BindingIdent) {\\n // async a => body\\n let arg = self.parse_binding_ident().map(Pat::from)?;\\n let params = vec![arg];\\n expect!(self, \"=>\");\\n let body = self.parse_fn_body(true, false)?;\\n\\n return Ok(Box::new(Expr::Arrow(ArrowExpr {\\n span: span!(self, start),\\n body,\\n params,\\n is_async: true,\\n is_generator: false,\\n return_type: None,\\n type_params: None,\\n })));\\n } else if can_be_arrow && !self.input.had_line_break_before_cur() && eat!(self, \"=>\") {\\n let params = vec![id.into()];\\n let body = self.parse_fn_body(false, false)?;\\n\\n return Ok(Box::new(Expr::Arrow(ArrowExpr {\\n span: span!(self, start),\\n body,\\n params,\\n is_async: false,\\n is_generator: false,\\n // TODO\\n return_type: None,\\n // TODO\\n type_params: None,\\n })));\\n } else {\\n return Ok(Box::new(Expr::Ident(id)));\\n }\\n }\\n\\n if self.input.syntax().private_in_object() {\\n if eat!(self, \\'#\\') {\\n let id = self.parse_ident_name()?;\\n return Ok(Box::new(Expr::PrivateName(PrivateName {\\n span: span!(self, start),\\n id,\\n })));\\n }\\n }\\n\\n unexpected!(\\n self,\\n \"this, import, async, function, [ for array literal, { for object literal, @ for \\\\\\n decorator, function, class, null, true, false, number, bigint, string, regexp, ` for \\\\\\n template literal, (, or an identifier\"\\n )\\n }\\n\\n fn parse_array_lit(&mut self) -> PResult> {\\n trace_cur!(self, parse_array_lit);\\n\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \\'[\\');\\n let mut elems = vec![];\\n\\n while !eof!(self) && !is!(self, \\']\\') {\\n if is!(self, \\',\\') {\\n expect!(self, \\',\\');\\n elems.push(None);\\n continue;\\n }\\n elems.push(\\n self.include_in_expr(true)\\n .parse_expr_or_spread()\\n .map(Some)?,\\n );\\n if !is!(self, \\']\\') {\\n expect!(self, \\',\\');\\n }\\n }\\n\\n expect!(self, \\']\\');\\n\\n let span = span!(self, start);\\n Ok(Box::new(Expr::Array(ArrayLit { span, elems })))\\n }\\n\\n fn parse_member_expr(&mut self) -> PResult> {\\n self.parse_member_expr_or_new_expr(false)\\n }\\n\\n /// `parseImportMetaProperty`\\n pub(super) fn parse_import_meta_prop(&mut self, import: Ident) -> PResult {\\n let start = cur_pos!(self);\\n\\n let meta = import;\\n\\n expect!(self, \\'.\\');\\n\\n let prop = if is!(self, \"meta\") {\\n self.parse_ident_name()?\\n } else {\\n unexpected!(self, \"meta\");\\n };\\n\\n Ok(MetaPropExpr { meta, prop })\\n }\\n\\n /// `is_new_expr`: true iff we are parsing production \\'NewExpression\\'.\\n fn parse_member_expr_or_new_expr(&mut self, is_new_expr: bool) -> PResult> {\\n trace_cur!(self, parse_member_expr_or_new_expr);\\n\\n let start = cur_pos!(self);\\n if eat!(self, \"new\") {\\n let span_of_new = span!(self, start);\\n if eat!(self, \\'.\\') {\\n let start_of_target = cur_pos!(self);\\n if eat!(self, \"target\") {\\n let expr = Box::new(Expr::MetaProp(MetaPropExpr {\\n meta: Ident::new(js_word!(\"new\"), span_of_new),\\n prop: Ident::new(js_word!(\"target\"), span!(self, start_of_target)),\\n }));\\n\\n return self.parse_subscripts(ExprOrSuper::Expr(expr), true);\\n }\\n\\n unexpected!(self, \"target\")\\n }\\n\\n // \\'NewExpression\\' allows new call without paren.\\n let callee = self.parse_member_expr_or_new_expr(is_new_expr)?;\\n return_if_arrow!(self, callee);\\n\\n let type_args = if self.input.syntax().typescript() && is!(self, \\'<\\') {\\n self.try_parse_ts(|p| {\\n let args = p.parse_ts_type_args()?;\\n if !is!(p, \\'(\\') {\\n // This will fail\\n expect!(p, \\'(\\');\\n }\\n Ok(Some(args))\\n })\\n } else {\\n None\\n };\\n\\n if !is_new_expr || is!(self, \\'(\\') {\\n // Parsed with \\'MemberExpression\\' production.\\n let args = self.parse_args(false).map(Some)?;\\n\\n let new_expr = ExprOrSuper::Expr(Box::new(Expr::New(NewExpr {\\n span: span!(self, start),\\n callee,\\n args,\\n type_args,\\n })));\\n\\n // We should parse subscripts for MemberExpression.\\n // Because it\\'s left recursive.\\n return self.parse_subscripts(new_expr, true);\\n }\\n\\n // Parsed with \\'NewExpression\\' production.\\n\\n return Ok(Box::new(Expr::New(NewExpr {\\n span: span!(self, start),\\n callee,\\n args: None,\\n type_args,\\n })));\\n }\\n\\n if eat!(self, \"super\") {\\n let base = ExprOrSuper::Super(Super {\\n span: span!(self, start),\\n });\\n return self.parse_subscripts(base, true);\\n }\\n let obj = self.parse_primary_expr()?;\\n return_if_arrow!(self, obj);\\n\\n self.parse_subscripts(ExprOrSuper::Expr(obj), true)\\n }\\n\\n /// Parse `NewExpression`.\\n /// This includes `MemberExpression`.\\n pub(super) fn parse_new_expr(&mut self) -> PResult> {\\n trace_cur!(self, parse_new_expr);\\n\\n self.parse_member_expr_or_new_expr(true)\\n }\\n\\n /// Parse `Arguments[Yield, Await]`\\n pub(super) fn parse_args(&mut self, is_dynamic_import: bool) -> PResult> {\\n trace_cur!(self, parse_args);\\n\\n let ctx = Context {\\n is_direct_child_of_cond: false,\\n ..self.ctx()\\n };\\n\\n self.with_ctx(ctx).parse_with(|p| {\\n let start = cur_pos!(p);\\n expect!(p, \\'(\\');\\n\\n let mut first = true;\\n let mut expr_or_spreads = Vec::with_capacity(8);\\n\\n while !eof!(p) && !is!(p, \\')\\') {\\n if first {\\n first = false;\\n } else {\\n expect!(p, \\',\\');\\n // Handle trailing comma.\\n if is!(p, \\')\\') {\\n if is_dynamic_import {\\n syntax_error!(\\n p,\\n span!(p, start),\\n SyntaxError::TrailingCommaInsideImport\\n )\\n }\\n\\n break;\\n }\\n }\\n\\n expr_or_spreads.push(p.include_in_expr(true).parse_expr_or_spread()?);\\n }\\n\\n expect!(p, \\')\\');\\n Ok(expr_or_spreads)\\n })\\n }\\n\\n /// AssignmentExpression[+In, ?Yield, ?Await]\\n /// ...AssignmentExpression[+In, ?Yield, ?Await]\\n pub(super) fn parse_expr_or_spread(&mut self) -> PResult {\\n trace_cur!(self, parse_expr_or_spread);\\n\\n let start = cur_pos!(self);\\n\\n if eat!(self, \"...\") {\\n let spread = Some(span!(self, start));\\n self.include_in_expr(true)\\n .parse_assignment_expr()\\n .map(|expr| ExprOrSpread { spread, expr })\\n } else {\\n self.parse_assignment_expr()\\n .map(|expr| ExprOrSpread { spread: None, expr })\\n }\\n }\\n\\n /// Parse paren expression or arrow function expression.\\n fn parse_paren_expr_or_arrow_fn(\\n &mut self,\\n can_be_arrow: bool,\\n async_span: Option,\\n ) -> PResult> {\\n trace_cur!(self, parse_paren_expr_or_arrow_fn);\\n\\n let expr_start = async_span.map(|x| x.lo()).unwrap_or(cur_pos!(self));\\n\\n // At this point, we can\\'t know if it\\'s parenthesized\\n // expression or head of arrow function.\\n // But as all patterns of javascript is subset of\\n // expressions, we can parse both as expression.\\n\\n let ctx = Context {\\n is_direct_child_of_cond: false,\\n ..self.ctx()\\n };\\n let paren_items = self\\n .with_ctx(ctx)\\n .include_in_expr(true)\\n .parse_args_or_pats()?;\\n let has_pattern = paren_items.iter().any(|item| match item {\\n PatOrExprOrSpread::Pat(..) => true,\\n _ => false,\\n });\\n\\n let is_direct_child_of_cond = self.ctx().is_direct_child_of_cond;\\n\\n // This is slow path. We handle arrow in conditional expression.\\n if self.syntax().typescript() && self.ctx().in_cond_expr && is!(self, \\':\\') {\\n // TODO: Remove clone\\n let items_ref = &paren_items;\\n if let Some(expr) = self.try_parse_ts(|p| {\\n let return_type = p.parse_ts_type_or_type_predicate_ann(&tok!(\\':\\'))?;\\n\\n expect!(p, \"=>\");\\n\\n let params = p\\n .parse_paren_items_as_params(items_ref.clone())?\\n .into_iter()\\n .collect();\\n\\n let body: BlockStmtOrExpr = p.parse_fn_body(async_span.is_some(), false)?;\\n\\n if is_direct_child_of_cond {\\n if !is_one_of!(p, \\':\\', \\';\\') {\\n trace_cur!(p, parse_arrow_in_cond__fail);\\n unexpected!(p, \"fail\")\\n }\\n }\\n\\n Ok(Some(Box::new(Expr::Arrow(ArrowExpr {\\n span: span!(p, expr_start),\\n is_async: async_span.is_some(),\\n is_generator: false,\\n params,\\n body,\\n return_type: Some(return_type),\\n type_params: None,\\n }))))\\n }) {\\n return Ok(expr);\\n }\\n }\\n\\n let return_type = if !(self.ctx().in_cond_expr && self.ctx().is_direct_child_of_cond)\\n && self.input.syntax().typescript()\\n && is!(self, \\':\\')\\n && !self.ctx().dont_parse_colon_as_type_ann\\n {\\n Some(self.parse_ts_type_or_type_predicate_ann(&tok!(\\':\\'))?)\\n } else {\\n None\\n };\\n\\n // we parse arrow function at here, to handle it efficiently.\\n if has_pattern || return_type.is_some() || is!(self, \"=>\") {\\n if self.input.had_line_break_before_cur() {\\n syntax_error!(\\n self,\\n span!(self, expr_start),\\n SyntaxError::LineBreakBeforeArrow\\n );\\n }\\n if !can_be_arrow {\\n syntax_error!(self, span!(self, expr_start), SyntaxError::ArrowNotAllowed);\\n }\\n expect!(self, \"=>\");\\n\\n let params = self\\n .parse_paren_items_as_params(paren_items)?\\n .into_iter()\\n .collect();\\n\\n let body: BlockStmtOrExpr = self.parse_fn_body(async_span.is_some(), false)?;\\n let arrow_expr = ArrowExpr {\\n span: span!(self, expr_start),\\n is_async: async_span.is_some(),\\n is_generator: false,\\n params,\\n body,\\n return_type,\\n type_params: None,\\n };\\n match arrow_expr.body {\\n BlockStmtOrExpr::BlockStmt(..) => match cur!(self, false) {\\n Ok(&Token::BinOp(..)) => {\\n // ) is required\\n self.emit_err(self.input.cur_span(), SyntaxError::TS1005);\\n let errored_expr =\\n self.parse_bin_op_recursively(Box::new(arrow_expr.into()), 0)?;\\n\\n if !is!(self, \\';\\') {\\n // ; is required\\n self.emit_err(self.input.cur_span(), SyntaxError::TS1005);\\n }\\n\\n return Ok(errored_expr);\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n return Ok(Box::new(Expr::Arrow(arrow_expr)));\\n }\\n\\n let expr_or_spreads = paren_items\\n .into_iter()\\n .map(|item| -> PResult<_> {\\n match item {\\n PatOrExprOrSpread::ExprOrSpread(e) => Ok(e),\\n _ => syntax_error!(self, item.span(), SyntaxError::InvalidExpr),\\n }\\n })\\n .collect::, _>>()?;\\n if let Some(async_span) = async_span {\\n // It\\'s a call expression\\n return Ok(Box::new(Expr::Call(CallExpr {\\n span: span!(self, async_span.lo()),\\n callee: ExprOrSuper::Expr(Box::new(Expr::Ident(Ident::new(\\n \"async\".into(),\\n async_span,\\n )))),\\n args: expr_or_spreads,\\n type_args: None,\\n })));\\n }\\n\\n // It was not head of arrow function.\\n\\n if expr_or_spreads.is_empty() {\\n syntax_error!(\\n self,\\n Span::new(expr_start, last_pos!(self), Default::default()),\\n SyntaxError::EmptyParenExpr\\n );\\n }\\n\\n // TODO: Verify that invalid expression like {a = 1} does not exists.\\n\\n // ParenthesizedExpression cannot contain spread.\\n if expr_or_spreads.len() == 1 {\\n let expr = match expr_or_spreads.into_iter().next().unwrap() {\\n ExprOrSpread {\\n spread: Some(..),\\n ref expr,\\n } => syntax_error!(self, expr.span(), SyntaxError::SpreadInParenExpr),\\n ExprOrSpread { expr, .. } => expr,\\n };\\n Ok(Box::new(Expr::Paren(ParenExpr {\\n span: span!(self, expr_start),\\n expr,\\n })))\\n } else {\\n debug_assert!(expr_or_spreads.len() >= 2);\\n\\n let mut exprs = Vec::with_capacity(expr_or_spreads.len());\\n for expr in expr_or_spreads {\\n match expr {\\n ExprOrSpread {\\n spread: Some(..),\\n ref expr,\\n } => syntax_error!(self, expr.span(), SyntaxError::SpreadInParenExpr),\\n ExprOrSpread { expr, .. } => exprs.push(expr),\\n }\\n }\\n debug_assert!(exprs.len() >= 2);\\n\\n // span of sequence expression should not include \\'(\\', \\')\\'\\n let seq_expr = Box::new(Expr::Seq(SeqExpr {\\n span: Span::new(\\n exprs.first().unwrap().span().lo(),\\n exprs.last().unwrap().span().hi(),\\n Default::default(),\\n ),\\n exprs,\\n }));\\n Ok(Box::new(Expr::Paren(ParenExpr {\\n span: span!(self, expr_start),\\n expr: seq_expr,\\n })))\\n }\\n }\\n\\n #[allow(clippy::vec_box)]\\n fn parse_tpl_elements(&mut self) -> PResult<(Vec>, Vec)> {\\n trace_cur!(self, parse_tpl_elements);\\n\\n let mut exprs = vec![];\\n\\n let cur_elem = self.parse_tpl_element()?;\\n let mut is_tail = cur_elem.tail;\\n let mut quasis = vec![cur_elem];\\n\\n while !is_tail {\\n expect!(self, \"${\");\\n exprs.push(self.include_in_expr(true).parse_expr()?);\\n expect!(self, \\'}\\');\\n let elem = self.parse_tpl_element()?;\\n is_tail = elem.tail;\\n quasis.push(elem);\\n }\\n\\n Ok((exprs, quasis))\\n }\\n\\n fn parse_tagged_tpl(\\n &mut self,\\n tag: Box,\\n type_params: Option,\\n ) -> PResult {\\n let tagged_tpl_start = tag.span().lo();\\n trace_cur!(self, parse_tagged_tpl);\\n\\n let tpl = self.parse_tpl()?;\\n\\n let span = span!(self, tagged_tpl_start);\\n Ok(TaggedTpl {\\n span,\\n tag,\\n type_params,\\n tpl,\\n })\\n }\\n\\n pub(super) fn parse_tpl(&mut self) -> PResult {\\n trace_cur!(self, parse_tpl);\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \\'`\\');\\n\\n let (exprs, quasis) = self.parse_tpl_elements()?;\\n\\n expect!(self, \\'`\\');\\n\\n let span = span!(self, start);\\n Ok(Tpl {\\n span,\\n exprs,\\n quasis,\\n })\\n }\\n\\n pub(super) fn parse_tpl_element(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n let (raw, cooked) = match *cur!(self, true)? {\\n Token::Template { .. } => match bump!(self) {\\n Token::Template {\\n raw,\\n cooked,\\n has_escape,\\n } => (\\n Str {\\n span: span!(self, start),\\n value: raw,\\n has_escape,\\n kind: StrKind::Normal {\\n contains_quote: false,\\n },\\n },\\n cooked.map(|cooked| Str {\\n span: span!(self, start),\\n value: cooked,\\n has_escape,\\n kind: StrKind::Normal {\\n contains_quote: false,\\n },\\n }),\\n ),\\n _ => unreachable!(),\\n },\\n _ => unexpected!(self, \"template token\"),\\n };\\n let tail = is!(self, \\'`\\');\\n Ok(TplElement {\\n span: span!(self, start),\\n raw,\\n tail,\\n\\n cooked,\\n })\\n }\\n\\n fn parse_subscripts(&mut self, mut obj: ExprOrSuper, no_call: bool) -> PResult> {\\n loop {\\n obj = match self.parse_subscript(obj, no_call)? {\\n (expr, false) => return Ok(expr),\\n (expr, true) => ExprOrSuper::Expr(expr),\\n }\\n }\\n }\\n\\n /// returned bool is true if this method should be called again.\\n #[allow(clippy::cognitive_complexity)]\\n fn parse_subscript(&mut self, obj: ExprOrSuper, no_call: bool) -> PResult<(Box, bool)> {\\n let _ = cur!(self, false);\\n let start = obj.span().lo();\\n\\n if self.input.syntax().typescript() {\\n if !self.input.had_line_break_before_cur() && is!(self, \\'!\\') {\\n self.input.set_expr_allowed(false);\\n assert_and_bump!(self, \\'!\\');\\n\\n let expr = match obj {\\n ExprOrSuper::Super(..) => unimplemented!(\"super!\"),\\n ExprOrSuper::Expr(expr) => expr,\\n };\\n return Ok((\\n Box::new(Expr::TsNonNull(TsNonNullExpr {\\n span: span!(self, start),\\n expr,\\n })),\\n true,\\n ));\\n }\\n\\n if {\\n match obj {\\n ExprOrSuper::Expr(..) => true,\\n // super() cannot be generic\\n _ => false,\\n }\\n } && is!(self, \\'<\\')\\n {\\n let obj_ref = &obj;\\n // tsTryParseAndCatch is expensive, so avoid if not necessary.\\n // There are number of things we are going to \"maybe\" parse, like type arguments\\n // on tagged template expressions. If any of them fail, walk it back and\\n // continue.\\n let result = self.try_parse_ts(|p| {\\n if !no_call\\n && p.at_possible_async(match obj_ref {\\n ExprOrSuper::Expr(ref expr) => &*expr,\\n _ => unreachable!(),\\n })?\\n {\\n // Almost certainly this is a generic async function `async () => ...\\n // But it might be a call with a type argument `async();`\\n let async_arrow_fn = p.try_parse_ts_generic_async_arrow_fn(start)?;\\n if let Some(async_arrow_fn) = async_arrow_fn {\\n return Ok(Some((Box::new(Expr::Arrow(async_arrow_fn)), true)));\\n }\\n }\\n\\n let type_args = p.parse_ts_type_args()?;\\n\\n if !no_call && is!(p, \\'(\\') {\\n // possibleAsync always false here, because we would have handled it\\n // above. (won\\'t be any undefined arguments)\\n let args = p.parse_args(is_import(&obj))?;\\n\\n Ok(Some((\\n Box::new(Expr::Call(CallExpr {\\n span: span!(p, start),\\n callee: obj_ref.clone(),\\n type_args: Some(type_args),\\n args,\\n })),\\n true,\\n )))\\n } else if is!(p, \\'`\\') {\\n p.parse_tagged_tpl(\\n match *obj_ref {\\n ExprOrSuper::Expr(ref obj) => obj.clone(),\\n _ => unreachable!(),\\n },\\n Some(type_args),\\n )\\n .map(|expr| (Box::new(Expr::TaggedTpl(expr)), true))\\n .map(Some)\\n } else {\\n if no_call {\\n unexpected!(p, \"`\")\\n } else {\\n unexpected!(p, \"( or `\")\\n }\\n }\\n });\\n if let Some(result) = result {\\n return Ok(result);\\n }\\n }\\n }\\n\\n let question_dot_token =\\n if self.input.syntax().optional_chaining() && is!(self, \\'?\\') && peeked_is!(self, \\'.\\') {\\n let start = cur_pos!(self);\\n eat!(self, \\'?\\');\\n Some(span!(self, start))\\n } else {\\n None\\n };\\n\\n /// Wrap with optional chaining\\n macro_rules! wrap {\\n ($e:expr) => {{\\n if let Some(question_dot_token) = question_dot_token {\\n Expr::OptChain(OptChainExpr {\\n span: span!(self, start),\\n question_dot_token,\\n expr: Box::new($e),\\n })\\n } else {\\n $e\\n }\\n }};\\n }\\n\\n // $obj[name()]\\n if (question_dot_token.is_some()\\n && is!(self, \\'.\\')\\n && peeked_is!(self, \\'[\\')\\n && eat!(self, \\'.\\')\\n && eat!(self, \\'[\\'))\\n || eat!(self, \\'[\\')\\n {\\n let prop = self.include_in_expr(true).parse_expr()?;\\n expect!(self, \\']\\');\\n let span = Span::new(obj.span().lo(), self.input.last_pos(), Default::default());\\n debug_assert_eq!(obj.span().lo(), span.lo());\\n\\n return Ok((\\n Box::new(wrap!(Expr::Member(MemberExpr {\\n span,\\n obj,\\n prop,\\n computed: true,\\n }))),\\n true,\\n ));\\n }\\n\\n if (question_dot_token.is_some()\\n && is!(self, \\'.\\')\\n && peeked_is!(self, \\'(\\')\\n && eat!(self, \\'.\\'))\\n || (!no_call && (is!(self, \\'(\\')))\\n {\\n let args = self.parse_args(is_import(&obj))?;\\n return Ok((\\n Box::new(wrap!(Expr::Call(CallExpr {\\n span: span!(self, start),\\n callee: obj,\\n args,\\n type_args: None,\\n }))),\\n true,\\n ));\\n }\\n\\n // member expression\\n // $obj.name\\n if eat!(self, \\'.\\') {\\n let prop: Box = Box::new(self.parse_maybe_private_name().map(|e| match e {\\n Either::Left(p) => Expr::PrivateName(p),\\n Either::Right(i) => Expr::Ident(i),\\n })?);\\n let span = span!(self, obj.span().lo());\\n debug_assert_eq!(obj.span().lo(), span.lo());\\n debug_assert_eq!(prop.span().hi(), span.hi());\\n\\n return Ok((\\n Box::new(wrap!(Expr::Member(MemberExpr {\\n span,\\n obj,\\n\\n prop,\\n computed: false,\\n }))),\\n true,\\n ));\\n }\\n\\n match obj {\\n ExprOrSuper::Expr(expr) => {\\n // MemberExpression[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]\\n if is!(self, \\'`\\') {\\n let tpl = self.parse_tagged_tpl(expr, None)?;\\n return Ok((Box::new(Expr::TaggedTpl(tpl)), true));\\n }\\n\\n Ok((expr, false))\\n }\\n ExprOrSuper::Super(..) => {\\n if no_call {\\n syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuperCall);\\n }\\n syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuper);\\n }\\n }\\n }\\n /// Parse call, dot, and `[]`-subscript expressions.\\n pub(super) fn parse_lhs_expr(&mut self) -> PResult> {\\n trace_cur!(self, parse_lhs_expr);\\n\\n let start = cur_pos!(self);\\n\\n // parse jsx\\n if self.input.syntax().jsx() {\\n fn into_expr(e: Either) -> Box {\\n match e {\\n Either::Left(l) => Box::new(l.into()),\\n Either::Right(r) => Box::new(Box::new(r).into()),\\n }\\n }\\n match *cur!(self, true)? {\\n Token::JSXText { .. } => {\\n return self\\n .parse_jsx_text()\\n .map(Lit::JSXText)\\n .map(Expr::Lit)\\n .map(Box::new);\\n }\\n Token::JSXTagStart => {\\n return self.parse_jsx_element().map(into_expr);\\n }\\n _ => {}\\n }\\n\\n if is!(self, \\'<\\') && !peeked_is!(self, \\'!\\') {\\n // In case we encounter an lt token here it will always be the start of\\n // jsx as the lt sign is not allowed in places that expect an expression\\n\\n // FIXME:\\n // self.finishToken(tt.jsxTagStart);\\n\\n return self.parse_jsx_element().map(into_expr);\\n }\\n }\\n\\n // `super()` can\\'t be handled from parse_new_expr()\\n if eat!(self, \"super\") {\\n let obj = ExprOrSuper::Super(Super {\\n span: span!(self, start),\\n });\\n return self.parse_subscripts(obj, false);\\n }\\n\\n let callee = self.parse_new_expr()?;\\n return_if_arrow!(self, callee);\\n\\n let type_args = if self.input.syntax().typescript() && is!(self, \\'<\\') {\\n self.try_parse_ts(|p| {\\n let type_args = p.parse_ts_type_args()?;\\n if is!(p, \\'(\\') {\\n Ok(Some(type_args))\\n } else {\\n Ok(None)\\n }\\n })\\n } else {\\n None\\n };\\n\\n if let Expr::New(ne @ NewExpr { args: None, .. }) = *callee {\\n // If this is parsed using \\'NewExpression\\' rule, just return it.\\n // Because it\\'s not left-recursive.\\n if type_args.is_some() {\\n // This fails with `expected (`\\n expect!(self, \\'(\\');\\n }\\n debug_assert_ne!(\\n cur!(self, false).ok(),\\n Some(&tok!(\\'(\\')),\\n \"parse_new_expr() should eat paren if it exists\"\\n );\\n return Ok(Box::new(Expr::New(NewExpr { type_args, ..ne })));\\n }\\n // \\'CallExpr\\' rule contains \\'MemberExpr (...)\\',\\n // and \\'MemberExpr\\' rule contains \\'new MemberExpr (...)\\'\\n\\n if is!(self, \\'(\\') {\\n // This is parsed using production MemberExpression,\\n // which is left-recursive.\\n let callee = ExprOrSuper::Expr(callee);\\n let args = self.parse_args(is_import(&callee))?;\\n\\n let call_expr = Box::new(Expr::Call(CallExpr {\\n span: span!(self, start),\\n\\n callee,\\n args,\\n type_args,\\n }));\\n\\n return self.parse_subscripts(ExprOrSuper::Expr(call_expr), false);\\n }\\n if type_args.is_some() {\\n // This fails\\n expect!(self, \\'(\\');\\n }\\n\\n // This is parsed using production \\'NewExpression\\', which contains\\n // \\'MemberExpression\\'\\n Ok(callee)\\n }\\n\\n pub(super) fn parse_expr_or_pat(&mut self) -> PResult> {\\n self.parse_expr()\\n }\\n\\n #[allow(clippy::cognitive_complexity)]\\n pub(super) fn parse_args_or_pats(&mut self) -> PResult> {\\n trace_cur!(self, parse_args_or_pats);\\n\\n expect!(self, \\'(\\');\\n\\n let mut first = true;\\n let mut items = vec![];\\n let mut rest_span = None;\\n\\n // TODO(kdy1): optimize (once we parsed a pattern, we can parse everything else\\n // as a pattern instead of reparsing)\\n while !eof!(self) && !is!(self, \\')\\') {\\n if first {\\n if is!(self, \"async\") {\\n // https://github.com/swc-project/swc/issues/410\\n self.state.potential_arrow_start = Some(cur_pos!(self));\\n let expr = self.parse_assignment_expr()?;\\n expect!(self, \\')\\');\\n return Ok(vec![PatOrExprOrSpread::ExprOrSpread(ExprOrSpread {\\n expr,\\n spread: None,\\n })]);\\n }\\n } else {\\n expect!(self, \\',\\');\\n // Handle trailing comma.\\n if is!(self, \\')\\') {\\n break;\\n }\\n }\\n\\n let start = cur_pos!(self);\\n self.state.potential_arrow_start = Some(start);\\n let modifier_start = start;\\n\\n let has_modifier = self.eat_any_ts_modifier()?;\\n let pat_start = cur_pos!(self);\\n\\n let mut arg = {\\n if self.input.syntax().typescript()\\n && (is!(self, IdentRef) || (is!(self, \"...\") && peeked_is!(self, IdentRef)))\\n {\\n let spread = if eat!(self, \"...\") {\\n Some(self.input.prev_span())\\n } else {\\n None\\n };\\n\\n // At here, we use parse_bin_expr() instead of parse_assignment_expr()\\n // because `x?: number` should not be parsed as a conditional expression\\n let expr = if spread.is_some() {\\n self.include_in_expr(true).parse_bin_expr()?\\n } else {\\n let mut expr = self.parse_bin_expr()?;\\n\\n if let Ok(&Token::AssignOp(..)) = cur!(self, false) {\\n expr = self.finish_assignment_expr(start, expr)?\\n }\\n\\n expr\\n };\\n\\n ExprOrSpread { spread, expr }\\n } else {\\n self.include_in_expr(true).parse_expr_or_spread()?\\n }\\n };\\n\\n let optional = if self.input.syntax().typescript() {\\n if is!(self, \\'?\\') {\\n if peeked_is!(self, \\',\\')\\n || peeked_is!(self, \\':\\')\\n || peeked_is!(self, \\')\\')\\n || peeked_is!(self, \\'=\\')\\n {\\n assert_and_bump!(self, \\'?\\');\\n let _ = cur!(self, false);\\n if arg.spread.is_some() {\\n self.emit_err(self.input.prev_span(), SyntaxError::TS1047);\\n }\\n match *arg.expr {\\n Expr::Ident(..) => {}\\n _ => {\\n syntax_error!(\\n self,\\n arg.span(),\\n SyntaxError::TsBindingPatCannotBeOptional\\n )\\n }\\n }\\n true\\n } else if match arg {\\n ExprOrSpread { spread: None, .. } => true,\\n _ => false,\\n } {\\n expect!(self, \\'?\\');\\n let test = arg.expr;\\n let ctx = Context {\\n in_cond_expr: true,\\n is_direct_child_of_cond: true,\\n include_in_expr: true,\\n ..self.ctx()\\n };\\n let cons = self.with_ctx(ctx).parse_assignment_expr()?;\\n expect!(self, \\':\\');\\n let ctx = Context {\\n in_cond_expr: true,\\n is_direct_child_of_cond: true,\\n ..self.ctx()\\n };\\n let alt = self.with_ctx(ctx).parse_assignment_expr()?;\\n\\n arg = ExprOrSpread {\\n spread: None,\\n expr: Box::new(Expr::Cond(CondExpr {\\n span: Span::new(start, alt.span().hi(), Default::default()),\\n\\n test,\\n cons,\\n alt,\\n })),\\n };\\n\\n false\\n } else {\\n false\\n }\\n } else {\\n false\\n }\\n } else {\\n false\\n };\\n\\n if optional || (self.input.syntax().typescript() && is!(self, \\':\\')) {\\n let start = cur_pos!(self);\\n\\n // TODO: `async(...args?: any[]) : any => {}`\\n //\\n // if self.input.syntax().typescript() && optional && arg.spread.is_some() {\\n // self.emit_err(self.input.prev_span(), SyntaxError::TS1047)\\n // }\\n\\n let mut pat = self.reparse_expr_as_pat(PatType::BindingPat, arg.expr)?;\\n if optional {\\n match pat {\\n Pat::Ident(ref mut i) => i.id.optional = true,\\n _ => unreachable!(),\\n }\\n }\\n if let Some(span) = arg.spread {\\n if let Some(rest_span) = rest_span {\\n if self.syntax().early_errors() {\\n // Rest pattern must be last one.\\n syntax_error!(self, rest_span, SyntaxError::NonLastRestParam);\\n }\\n }\\n rest_span = Some(span);\\n pat = Pat::Rest(RestPat {\\n span: span!(self, pat_start),\\n dot3_token: span,\\n arg: Box::new(pat),\\n type_ann: None,\\n });\\n }\\n match pat {\\n Pat::Ident(BindingIdent {\\n id: Ident { ref mut span, .. },\\n ref mut type_ann,\\n ..\\n })\\n | Pat::Array(ArrayPat {\\n ref mut type_ann,\\n ref mut span,\\n ..\\n })\\n | Pat::Assign(AssignPat {\\n ref mut type_ann,\\n ref mut span,\\n ..\\n })\\n | Pat::Object(ObjectPat {\\n ref mut type_ann,\\n ref mut span,\\n ..\\n })\\n | Pat::Rest(RestPat {\\n ref mut type_ann,\\n ref mut span,\\n ..\\n }) => {\\n let new_type_ann = self.try_parse_ts_type_ann()?;\\n if new_type_ann.is_some() {\\n *span =\\n Span::new(pat_start, self.input.prev_span().hi, Default::default());\\n }\\n *type_ann = new_type_ann;\\n }\\n Pat::Expr(ref expr) => unreachable!(\"invalid pattern: Expr({:?})\", expr),\\n Pat::Invalid(ref i) => {\\n // We don\\'t have to panic here.\\n // See: https://github.com/swc-project/swc/issues/1170\\n //\\n // Also, as an exact error is added to the errors while\\n // creating `Invalid`, we don\\'t have to emit a new\\n // error.\\n }\\n }\\n\\n if eat!(self, \\'=\\') {\\n let right = self.parse_assignment_expr()?;\\n pat = Pat::Assign(AssignPat {\\n span: span!(self, pat_start),\\n left: Box::new(pat),\\n right,\\n type_ann: None,\\n });\\n }\\n\\n if has_modifier {\\n self.emit_err(span!(self, modifier_start), SyntaxError::TS2369);\\n }\\n\\n items.push(PatOrExprOrSpread::Pat(pat))\\n } else {\\n if has_modifier {\\n self.emit_err(span!(self, modifier_start), SyntaxError::TS2369);\\n }\\n\\n items.push(PatOrExprOrSpread::ExprOrSpread(arg));\\n }\\n\\n // https://github.com/swc-project/swc/issues/433\\n if first && eat!(self, \"=>\") && {\\n debug_assert_eq!(items.len(), 1);\\n match items[0] {\\n PatOrExprOrSpread::ExprOrSpread(ExprOrSpread { ref expr, .. })\\n | PatOrExprOrSpread::Pat(Pat::Expr(ref expr)) => match **expr {\\n Expr::Ident(..) => true,\\n _ => false,\\n },\\n PatOrExprOrSpread::Pat(Pat::Ident(..)) => true,\\n _ => false,\\n }\\n } {\\n let params = self\\n .parse_paren_items_as_params(items)?\\n .into_iter()\\n .collect();\\n\\n let body: BlockStmtOrExpr = self.parse_fn_body(false, false)?;\\n expect!(self, \\')\\');\\n let span = span!(self, start);\\n\\n return Ok(vec![PatOrExprOrSpread::ExprOrSpread(ExprOrSpread {\\n expr: Box::new(\\n ArrowExpr {\\n span,\\n body,\\n is_async: false,\\n is_generator: false,\\n params,\\n type_params: None,\\n return_type: None,\\n }\\n .into(),\\n ),\\n spread: None,\\n })]);\\n }\\n\\n first = false;\\n }\\n\\n expect!(self, \\')\\');\\n Ok(items)\\n }\\n}\\n\\n#[ast_node]\\npub(in crate::parser) enum PatOrExprOrSpread {\\n #[tag(\"*\")]\\n Pat(Pat),\\n #[tag(\"*\")]\\n ExprOrSpread(ExprOrSpread),\\n}\\n\\n/// simple leaf methods.\\n\\nimpl<\\'a, I: Tokens> Parser {\\n fn parse_yield_expr(&mut self) -> PResult> {\\n let start = cur_pos!(self);\\n\\n assert_and_bump!(self, \"yield\");\\n debug_assert!(self.ctx().in_generator);\\n\\n // Spec says\\n // YieldExpression cannot be used within the FormalParameters of a generator\\n // function because any expressions that are part of FormalParameters are\\n // evaluated before the resulting generator object is in a resumable state.\\n if self.ctx().in_parameters {\\n syntax_error!(self, self.input.prev_span(), SyntaxError::YieldParamInGen)\\n }\\n\\n if is!(self, \\';\\')\\n || (!is!(self, \\'*\\') && !cur!(self, false).map(Token::starts_expr).unwrap_or(true))\\n {\\n Ok(Box::new(Expr::Yield(YieldExpr {\\n span: span!(self, start),\\n arg: None,\\n delegate: false,\\n })))\\n } else {\\n let has_star = eat!(self, \\'*\\');\\n let arg = self.parse_assignment_expr()?;\\n\\n Ok(Box::new(Expr::Yield(YieldExpr {\\n span: span!(self, start),\\n arg: Some(arg),\\n delegate: has_star,\\n })))\\n }\\n }\\n\\n fn at_possible_async(&mut self, expr: &Expr) -> PResult {\\n // TODO(kdy1): !this.state.containsEsc &&\\n\\n Ok(self.state.potential_arrow_start == Some(expr.span().lo())\\n && match *expr {\\n Expr::Ident(Ident {\\n sym: js_word!(\"async\"),\\n ..\\n }) => true,\\n _ => false,\\n })\\n }\\n\\n /// 12.2.5 Array Initializer\\n pub(super) fn parse_lit(&mut self) -> PResult {\\n let start = cur_pos!(self);\\n\\n let v = match cur!(self, true)? {\\n Word(Word::Null) => {\\n bump!(self);\\n let span = span!(self, start);\\n Lit::Null(Null { span })\\n }\\n Word(Word::True) | Word(Word::False) => {\\n let value = is!(self, \"true\");\\n bump!(self);\\n let span = span!(self, start);\\n\\n Lit::Bool(Bool { span, value })\\n }\\n Token::Str { .. } => match bump!(self) {\\n Token::Str { value, has_escape } => Lit::Str(Str {\\n span: span!(self, start),\\n value,\\n has_escape,\\n kind: StrKind::Normal {\\n contains_quote: true,\\n },\\n }),\\n _ => unreachable!(),\\n },\\n Token::Num(..) => match bump!(self) {\\n Token::Num(value) => Lit::Num(Number {\\n span: span!(self, start),\\n value,\\n }),\\n _ => unreachable!(),\\n },\\n Token::BigInt(..) => match bump!(self) {\\n Token::BigInt(value) => Lit::BigInt(BigInt {\\n span: span!(self, start),\\n value,\\n }),\\n _ => unreachable!(),\\n },\\n token => unreachable!(\"parse_lit should not be called for {:?}\", token),\\n };\\n Ok(v)\\n }\\n\\n pub(super) fn parse_dynamic_import(\\n &mut self,\\n start: BytePos,\\n import_ident: Ident,\\n ) -> PResult> {\\n if !self.input.syntax().dynamic_import() {\\n syntax_error!(self, span!(self, start), SyntaxError::DynamicImport);\\n }\\n\\n let args = self.parse_args(true)?;\\n let import = Box::new(Expr::Call(CallExpr {\\n span: span!(self, start),\\n callee: ExprOrSuper::Expr(Box::new(Expr::Ident(import_ident))),\\n args,\\n type_args: Default::default(),\\n }));\\n\\n self.parse_subscripts(ExprOrSuper::Expr(import), true)\\n }\\n\\n pub(super) fn check_assign_target(&mut self, expr: &Expr, deny_call: bool) {\\n // We follow behavior of tsc\\n if self.input.syntax().typescript() && self.syntax().early_errors() {\\n let is_eval_or_arguments = match *expr {\\n Expr::Ident(ref i) => i.sym == js_word!(\"eval\") || i.sym == js_word!(\"arguments\"),\\n _ => false,\\n };\\n\\n if is_eval_or_arguments {\\n self.emit_strict_mode_err(expr.span(), SyntaxError::TS1100);\\n }\\n\\n fn should_deny(e: &Expr, deny_call: bool) -> bool {\\n match e {\\n Expr::Lit(..) => false,\\n Expr::Call(..) => deny_call,\\n Expr::Bin(..) => false,\\n Expr::Paren(ref p) => should_deny(&p.expr, deny_call),\\n\\n _ => true,\\n }\\n }\\n\\n // It is an early Reference Error if LeftHandSideExpression is neither\\n // an ObjectLiteral nor an ArrayLiteral and\\n // IsValidSimpleAssignmentTarget of LeftHandSideExpression is false.\\n if !is_eval_or_arguments\\n && !expr.is_valid_simple_assignment_target(self.ctx().strict)\\n && should_deny(&expr, deny_call)\\n {\\n self.emit_err(expr.span(), SyntaxError::TS2406);\\n }\\n } else {\\n if !expr.is_valid_simple_assignment_target(self.ctx().strict) {\\n self.emit_err(expr.span(), SyntaxError::TS2406);\\n }\\n }\\n }\\n}\\n\\nfn is_import(obj: &ExprOrSuper) -> bool {\\n match *obj {\\n ExprOrSuper::Expr(ref expr) => match **expr {\\n Expr::Ident(Ident {\\n sym: js_word!(\"import\"),\\n ..\\n }) => true,\\n _ => false,\\n },\\n _ => false,\\n }\\n}\\n',\n", + " 'content_id': '0df9ca51b3390b0113eeb87e06c0b1f08fbfe3c0',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/parser/src/parser/expr.rs',\n", + " 'size': 60313,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6218867924528302,\n", + " 'avg_line_length': 41.74193548387097,\n", + " 'blob_id': '65264f764fd0d497bd63b89d81969419aae40a49',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms_optimization/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms_module\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.44.0\"\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nInflector = \"0.11.4\"\\nanyhow = \"1.0.41\"\\nindexmap = \"1.6.1\"\\npathdiff = \"0.2.0\"\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1.0.118\", features = [\"derive\"]}\\nswc_atoms = {version = \"0.2\", path = \"../../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../../ast\"}\\nswc_ecma_loader = {version = \"0.20.0\", path = \"../../loader\", features = [\"node\"]}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../../parser\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"../base\"}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../../visit\"}\\n\\n[dev-dependencies]\\nswc_ecma_transforms_compat = {version = \"0.40.0\", path = \"../compat\"}\\nswc_ecma_transforms_testing = {version = \"0.36.0\", path = \"../testing/\"}\\ntesting = {version = \"0.14.0\", path = \"../../../testing/\"}\\n',\n", + " 'content_id': '9f97ed539ea110070fd9c1e975dbd9ba3d0cc24b',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/transforms/module/Cargo.toml',\n", + " 'size': 1325,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3537115470352207,\n", + " 'avg_line_length': 35.032128514056225,\n", + " 'blob_id': 'b94652edf2864dbc06e08b3ff607c2f48facc597',\n", + " 'content': 'use crate::path::ImportResolver;\\nuse anyhow::Context;\\nuse indexmap::IndexMap;\\nuse inflector::Inflector;\\nuse rustc_hash::{FxHashMap, FxHashSet, FxHasher};\\nuse serde::{Deserialize, Serialize};\\nuse std::{\\n cell::{Ref, RefMut},\\n collections::hash_map::Entry,\\n hash::BuildHasherDefault,\\n iter,\\n};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{\\n collections::{AHashMap, AHashSet},\\n util::take::Take,\\n FileName, Mark, Span, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{\\n ident::IdentLike, member_expr, private_ident, quote_ident, quote_str, undefined,\\n DestructuringFinder, ExprFactory, Id,\\n};\\nuse swc_ecma_visit::{Fold, FoldWith, VisitWith};\\n\\npub(super) trait ModulePass: Fold {\\n fn config(&self) -> &Config;\\n fn scope(&self) -> Ref;\\n fn scope_mut(&mut self) -> RefMut;\\n\\n fn make_dynamic_import(&mut self, span: Span, args: Vec) -> Expr;\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct Config {\\n #[serde(default)]\\n pub strict: bool,\\n #[serde(default = \"default_strict_mode\")]\\n pub strict_mode: bool,\\n #[serde(default)]\\n pub lazy: Lazy,\\n #[serde(default)]\\n pub no_interop: bool,\\n}\\n\\nimpl Default for Config {\\n fn default() -> Self {\\n Config {\\n strict: false,\\n strict_mode: default_strict_mode(),\\n lazy: Lazy::default(),\\n no_interop: false,\\n }\\n }\\n}\\n\\nconst fn default_strict_mode() -> bool {\\n true\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(untagged, deny_unknown_fields, rename_all = \"camelCase\")]\\npub enum Lazy {\\n Bool(bool),\\n List(Vec),\\n}\\n\\nimpl Lazy {\\n pub fn is_lazy(&self, src: &JsWord) -> bool {\\n match *self {\\n Lazy::Bool(false) => false,\\n Lazy::Bool(true) => !src.starts_with(\\'.\\'),\\n Lazy::List(ref srcs) => srcs.contains(&src),\\n }\\n }\\n}\\n\\nimpl Default for Lazy {\\n fn default() -> Self {\\n Lazy::Bool(false)\\n }\\n}\\n\\n#[derive(Clone, Default)]\\npub struct Scope {\\n /// Map from source file to ident\\n ///\\n /// e.g.\\n ///\\n /// - `import \\'foo\\'`\\n /// -> `{\\'foo\\': None}`\\n ///\\n /// - `import { foo } from \\'bar\\';`\\n /// -> `{\\'bar\\': Some(_bar)}`\\n ///\\n /// - `import * as bar1 from \\'bar\\';`\\n /// -> `{\\'bar\\': Some(bar1)}`\\n pub(crate) imports: IndexMap, BuildHasherDefault>,\\n ///\\n /// - `true` is wildcard (`_interopRequireWildcard`)\\n /// - `false` is default (`_interopRequireDefault`)\\n pub(crate) import_types: FxHashMap,\\n\\n /// This fields tracks if a helper should be injected.\\n ///\\n /// `(need_wildcard, need_default)`\\n pub(crate) unknown_imports: (bool, bool),\\n\\n /// Map from imported ident to (source file, property name).\\n ///\\n /// e.g.\\n /// - `import { foo } from \\'bar\\';`\\n /// -> `{foo: (\\'bar\\', foo)}`\\n ///\\n /// - `import foo from \\'bar\\';`\\n /// -> `{foo: (\\'bar\\', default)}`\\n pub(crate) idents: FxHashMap,\\n\\n /// Declared variables except const.\\n pub(crate) declared_vars: Vec,\\n\\n /// Maps of exported variables.\\n ///\\n ///\\n /// e.g.\\n /// - `export { a }`\\n /// -> `{ a: [a] }`\\n ///\\n /// - `export { a as b }`\\n /// -> `{ a: [b] }`\\n pub(crate) exported_vars: AHashMap>,\\n\\n /// This is required to handle\\n /// `export * from \\'foo\\';`\\n pub(crate) lazy_blacklist: AHashSet,\\n}\\n\\nimpl Scope {\\n ///\\n /// ```js\\n /// Object.keys(_foo).forEach(function (key) {\\n /// if (key === \"default\" || key === \"__esModule\") return;\\n /// if (key in exports && exports[key] === _foo[key]) return;\\n /// Object.defineProperty(exports, key, {\\n /// enumerable: true,\\n /// get: function () {\\n /// return _foo[key];\\n /// }\\n /// });\\n /// })\\n /// ```\\n ///\\n /// # Parameters\\n /// - `exported_names` Ident of the object literal.\\n pub fn handle_export_all(\\n &mut self,\\n exports: Ident,\\n exported_names: Option,\\n export: ExportAll,\\n ) -> Stmt {\\n let imported = self.import_to_export(&export.src, true).unwrap();\\n\\n let key_ident = private_ident!(\"key\");\\n\\n let function = Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n params: vec![Param {\\n span: DUMMY_SP,\\n decorators: Default::default(),\\n pat: Pat::Ident(key_ident.clone().into()),\\n }],\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: iter::once(Stmt::If(IfStmt {\\n span: DUMMY_SP,\\n // key === \"default\" || key === \"__esModule\"\\n test: Box::new(\\n key_ident\\n .clone()\\n .make_eq(Lit::Str(quote_str!(\"default\")))\\n .make_bin(\\n op!(\"||\"),\\n key_ident\\n .clone()\\n .make_eq(Lit::Str(quote_str!(\"__esModule\"))),\\n ),\\n ),\\n cons: Box::new(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: None,\\n })),\\n alt: None,\\n }))\\n .chain({\\n // We should skip if the file explicitly exports\\n if let Some(exported_names) = exported_names {\\n // `if (Object.prototype.hasOwnProperty.call(_exportNames, key))\\n // return;`\\n Some(Stmt::If(IfStmt {\\n span: DUMMY_SP,\\n test: Box::new(\\n CallExpr {\\n span: DUMMY_SP,\\n callee: member_expr!(\\n DUMMY_SP,\\n Object.prototype.hasOwnProperty.call\\n )\\n .as_callee(),\\n args: vec![exported_names.as_arg(), key_ident.clone().as_arg()],\\n type_args: Default::default(),\\n }\\n .into(),\\n ),\\n cons: Box::new(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: None,\\n })),\\n alt: None,\\n }))\\n } else {\\n None\\n }\\n })\\n .chain({\\n Some(Stmt::If(IfStmt {\\n span: DUMMY_SP,\\n test: Box::new(\\n key_ident\\n .clone()\\n .make_bin(op!(\"in\"), exports.clone())\\n .make_bin(\\n op!(\"&&\"),\\n exports.clone().computed_member(key_ident.clone()).make_eq(\\n imported.clone().computed_member(key_ident.clone()),\\n ),\\n ),\\n ),\\n cons: Box::new(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: None,\\n })),\\n alt: None,\\n }))\\n })\\n .chain(iter::once(\\n define_property(vec![\\n exports.as_arg(),\\n key_ident.clone().as_arg(),\\n make_descriptor(Box::new(imported.clone().computed_member(key_ident)))\\n .as_arg(),\\n ])\\n .into_stmt(),\\n ))\\n .collect(),\\n }),\\n return_type: Default::default(),\\n type_params: Default::default(),\\n };\\n\\n CallExpr {\\n span: DUMMY_SP,\\n // Object.keys(_foo).forEach\\n callee: CallExpr {\\n span: DUMMY_SP,\\n callee: member_expr!(DUMMY_SP, Object.keys).as_callee(),\\n args: vec![imported.as_arg()],\\n type_args: Default::default(),\\n }\\n .make_member(quote_ident!(\"forEach\"))\\n .as_callee(),\\n args: vec![FnExpr {\\n ident: None,\\n function,\\n }\\n .as_arg()],\\n type_args: Default::default(),\\n }\\n .into_stmt()\\n }\\n\\n /// Import src to export from it.\\n pub fn import_to_export(&mut self, src: &Str, init: bool) -> Option {\\n let entry = self\\n .imports\\n .entry(src.value.clone())\\n .and_modify(|v| {\\n if init && v.is_none() {\\n *v = {\\n let ident = private_ident!(local_name_for_src(&src.value));\\n Some((ident.sym, ident.span))\\n }\\n }\\n })\\n .or_insert_with(|| {\\n if init {\\n let ident = private_ident!(local_name_for_src(&src.value));\\n Some((ident.sym, ident.span))\\n } else {\\n None\\n }\\n });\\n if init {\\n let entry = entry.as_ref().unwrap();\\n let ident = Ident::new(entry.0.clone(), entry.1);\\n\\n Some(ident)\\n } else {\\n None\\n }\\n }\\n\\n pub fn insert_import(&mut self, mut import: ImportDecl) {\\n if import.specifiers.is_empty() {\\n // import \\'foo\\';\\n // -> require(\\'foo\\');\\n self.imports.entry(import.src.value.clone()).or_insert(None);\\n } else if import.specifiers.len() == 1\\n && match import.specifiers[0] {\\n ImportSpecifier::Namespace(..) => true,\\n _ => false,\\n }\\n {\\n // import * as foo from \\'src\\';\\n let specifier = match import.specifiers.pop().unwrap() {\\n ImportSpecifier::Namespace(ns) => ns,\\n _ => unreachable!(),\\n };\\n\\n self.idents.insert(\\n (specifier.local.sym.clone(), specifier.local.span.ctxt()),\\n (import.src.value.clone(), \"\".into()),\\n );\\n\\n // Override symbol if one exists\\n self.imports\\n .entry(import.src.value.clone())\\n .and_modify(|v| match *v {\\n Some(ref mut v) => v.0 = specifier.local.sym.clone(),\\n None => *v = Some((specifier.local.sym.clone(), specifier.local.span)),\\n })\\n .or_insert_with(|| Some((specifier.local.sym.clone(), specifier.local.span)));\\n\\n if &*import.src.value != \"@swc/helpers\" {\\n self.import_types.insert(import.src.value, true);\\n }\\n } else {\\n self.imports\\n .entry(import.src.value.clone())\\n .and_modify(|opt| {\\n if opt.is_none() {\\n let ident =\\n private_ident!(import.src.span, local_name_for_src(&import.src.value));\\n *opt = Some((ident.sym, ident.span));\\n }\\n })\\n .or_insert_with(|| {\\n let ident =\\n private_ident!(import.src.span, local_name_for_src(&import.src.value));\\n Some((ident.sym, ident.span))\\n });\\n\\n let mut has_non_default = false;\\n for s in import.specifiers {\\n match s {\\n ImportSpecifier::Namespace(ref ns) => {\\n self.idents.insert(\\n (ns.local.sym.clone(), ns.local.span.ctxt()),\\n (import.src.value.clone(), \"\".into()),\\n );\\n\\n // Override symbol if one exists\\n self.imports\\n .entry(import.src.value.clone())\\n .and_modify(|v| match *v {\\n Some(ref mut v) => v.0 = ns.local.sym.clone(),\\n None => *v = Some((ns.local.sym.clone(), ns.local.span)),\\n })\\n .or_insert_with(|| Some((ns.local.sym.clone(), ns.local.span)));\\n\\n if &*import.src.value != \"@swc/helpers\" {\\n self.import_types.insert(import.src.value.clone(), true);\\n }\\n }\\n ImportSpecifier::Default(i) => {\\n self.idents.insert(\\n i.local.to_id(),\\n (import.src.value.clone(), js_word!(\"default\")),\\n );\\n self.import_types\\n .entry(import.src.value.clone())\\n .or_insert(false);\\n }\\n ImportSpecifier::Named(i) => {\\n let ImportNamedSpecifier {\\n local, imported, ..\\n } = i;\\n let name = imported.map(|i| i.sym).unwrap_or_else(|| local.sym.clone());\\n let is_default = name == js_word!(\"default\");\\n\\n self.idents\\n .insert(local.to_id(), (import.src.value.clone(), name));\\n\\n if is_default {\\n self.import_types\\n .entry(import.src.value.clone())\\n .or_insert(has_non_default);\\n } else {\\n has_non_default = true;\\n self.import_types\\n .entry(import.src.value.clone())\\n .and_modify(|v| *v = true);\\n }\\n }\\n }\\n }\\n }\\n }\\n\\n pub(super) fn fold_shorthand_prop(\\n folder: &mut impl ModulePass,\\n top_level: bool,\\n prop: Ident,\\n ) -> Prop {\\n let key = prop.clone();\\n let value = Scope::fold_ident(folder, top_level, prop);\\n match value {\\n Ok(value) => Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(key),\\n value: Box::new(value),\\n }),\\n Err(ident) => Prop::Shorthand(ident),\\n }\\n }\\n\\n fn fold_ident(folder: &mut impl ModulePass, top_level: bool, i: Ident) -> Result {\\n let v = folder.scope().idents.get(&i.to_id()).cloned();\\n match v {\\n None => Err(i),\\n Some((src, prop)) => {\\n if top_level {\\n folder.scope_mut().lazy_blacklist.insert(src.clone());\\n }\\n\\n let lazy = if folder.scope().lazy_blacklist.contains(&src) {\\n false\\n } else {\\n folder.config().lazy.is_lazy(&src)\\n };\\n\\n let scope = folder.scope();\\n let (ident, span) = scope.imports.get(&src).as_ref().unwrap().as_ref().unwrap();\\n\\n let obj = {\\n let ident = Ident::new(ident.clone(), *span);\\n\\n if lazy {\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: ident.as_callee(),\\n args: vec![],\\n type_args: Default::default(),\\n })\\n } else {\\n Expr::Ident(ident)\\n }\\n };\\n\\n if *prop == js_word!(\"\") {\\n // import * as foo from \\'foo\\';\\n Ok(obj)\\n } else {\\n Ok(obj.make_member(Ident::new(prop, DUMMY_SP)))\\n }\\n }\\n }\\n }\\n\\n pub(super) fn fold_expr(\\n folder: &mut impl ModulePass,\\n exports: Ident,\\n top_level: bool,\\n expr: Expr,\\n ) -> Expr {\\n macro_rules! chain_assign {\\n ($entry:expr, $e:expr) => {{\\n let mut e = $e;\\n for i in $entry.get() {\\n e = Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports\\n .clone()\\n .make_member(Ident::new(i.0.clone(), DUMMY_SP.with_ctxt(i.1))),\\n )),\\n op: op!(\"=\"),\\n right: e,\\n }));\\n }\\n e\\n }};\\n }\\n\\n match expr {\\n Expr::This(ThisExpr { span }) if top_level => *undefined(span),\\n Expr::Ident(i) => match Self::fold_ident(folder, top_level, i) {\\n Ok(expr) => expr,\\n Err(ident) => Expr::Ident(ident),\\n },\\n\\n // Handle dynamic imports.\\n // See https://github.com/swc-project/swc/issues/1018\\n Expr::Call(CallExpr {\\n span,\\n callee: ExprOrSuper::Expr(callee),\\n args,\\n ..\\n }) if args.len() == 1\\n && match *callee {\\n Expr::Ident(Ident {\\n sym: js_word!(\"import\"),\\n ..\\n }) => true,\\n _ => false,\\n } =>\\n {\\n folder.make_dynamic_import(span, args)\\n }\\n\\n Expr::Call(CallExpr {\\n span,\\n callee,\\n args,\\n type_args,\\n }) => {\\n let callee = if let ExprOrSuper::Expr(expr) = callee {\\n let callee = if let Expr::Ident(ident) = *expr {\\n match Self::fold_ident(folder, top_level, ident) {\\n Ok(mut expr) => {\\n if let Expr::Member(member) = &mut expr {\\n if let ExprOrSuper::Expr(expr) = &mut member.obj {\\n if let Expr::Ident(ident) = expr.as_mut() {\\n member.obj = ExprOrSuper::Expr(Box::new(Expr::Paren(\\n ParenExpr {\\n expr: Box::new(Expr::Seq(SeqExpr {\\n span,\\n exprs: vec![\\n Box::new(0_f64.into()),\\n Box::new(ident.take().into()),\\n ],\\n })),\\n span,\\n },\\n )))\\n }\\n }\\n };\\n expr\\n }\\n Err(ident) => Expr::Ident(ident),\\n }\\n } else {\\n *expr.fold_with(folder)\\n };\\n ExprOrSuper::Expr(Box::new(callee))\\n } else {\\n callee.fold_with(folder)\\n };\\n Expr::Call(CallExpr {\\n span,\\n callee,\\n args: args.fold_with(folder),\\n type_args,\\n })\\n }\\n\\n Expr::Member(e) => {\\n if e.computed {\\n Expr::Member(MemberExpr {\\n obj: e.obj.fold_with(folder),\\n prop: e.prop.fold_with(folder),\\n ..e\\n })\\n } else {\\n Expr::Member(MemberExpr {\\n obj: e.obj.fold_with(folder),\\n ..e\\n })\\n }\\n }\\n\\n Expr::Update(UpdateExpr {\\n span,\\n arg,\\n op,\\n prefix,\\n }) if arg.is_ident() => {\\n let arg = arg.ident().unwrap();\\n let mut scope = folder.scope_mut();\\n let entry = scope\\n .exported_vars\\n .entry((arg.sym.clone(), arg.span.ctxt()));\\n\\n match entry {\\n Entry::Occupied(entry) => {\\n let e = chain_assign!(\\n entry,\\n Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(arg.clone().into()))),\\n op: op!(\"=\"),\\n right: Box::new(Expr::Bin(BinExpr {\\n span: DUMMY_SP,\\n left: Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(unary, \"+\"),\\n arg: Box::new(Expr::Ident(arg)),\\n })),\\n op: match op {\\n op!(\"++\") => op!(bin, \"+\"),\\n op!(\"--\") => op!(bin, \"-\"),\\n },\\n right: Box::new(Expr::Lit(Lit::Num(Number {\\n span: DUMMY_SP,\\n value: 1.0,\\n }))),\\n })),\\n }))\\n );\\n\\n *e\\n }\\n _ => Expr::Update(UpdateExpr {\\n span,\\n arg: Box::new(Expr::Ident(arg)),\\n op,\\n prefix,\\n }),\\n }\\n }\\n\\n Expr::Assign(mut expr) => {\\n expr.left = expr.left.fold_with(folder);\\n expr.right = expr.right.fold_with(folder);\\n\\n let mut found: Vec<(JsWord, Span)> = vec![];\\n let mut v = DestructuringFinder { found: &mut found };\\n expr.left\\n .visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n if v.found.is_empty() {\\n return Expr::Assign(AssignExpr {\\n left: expr.left,\\n ..expr\\n });\\n }\\n\\n // imports are read-only\\n for i in &found {\\n let i = Ident::new(i.0.clone(), i.1);\\n if folder\\n .scope()\\n .idents\\n .get(&(i.sym.clone(), i.span.ctxt()))\\n .is_some()\\n {\\n let throw = Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n params: vec![],\\n body: Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![\\n // throw new Error(\\'\"\\' + \"Foo\" + \\'\" is read-only.\\')\\n Stmt::Throw(ThrowStmt {\\n span: DUMMY_SP,\\n arg: Box::new(Expr::New(NewExpr {\\n span: DUMMY_SP,\\n callee: Box::new(Expr::Ident(quote_ident!(\\n \"Error\"\\n ))),\\n args: Some(vec![quote_str!(\"\\\\\"\")\\n .make_bin(\\n op!(bin, \"+\"),\\n quote_str!(i.span, i.sym),\\n )\\n .make_bin(\\n op!(bin, \"+\"),\\n quote_str!(\"\\\\\" is read-only.\"),\\n )\\n .as_arg()]),\\n type_args: Default::default(),\\n })),\\n }),\\n ],\\n }),\\n return_type: Default::default(),\\n type_params: Default::default(),\\n },\\n }\\n .as_callee(),\\n args: vec![],\\n type_args: Default::default(),\\n });\\n\\n let left = if let PatOrExpr::Pat(ref left_pat) = expr.left {\\n if let Pat::Ident(BindingIdent { ref id, .. }) = **left_pat {\\n let expr = match Self::fold_ident(folder, top_level, id.clone()) {\\n Ok(expr) => expr,\\n Err(ident) => Expr::Ident(ident),\\n };\\n PatOrExpr::Expr(Box::new(expr))\\n } else {\\n expr.left\\n }\\n } else {\\n expr.left\\n };\\n\\n return Expr::Assign(AssignExpr {\\n right: Box::new(Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs: vec![expr.right, Box::new(throw)],\\n })),\\n left,\\n ..expr\\n });\\n }\\n }\\n\\n match expr.left {\\n PatOrExpr::Pat(pat) if pat.is_ident() => {\\n let i = pat.ident().unwrap();\\n let mut scope = folder.scope_mut();\\n let entry = scope\\n .exported_vars\\n .entry((i.id.sym.clone(), i.id.span.ctxt()));\\n\\n match entry {\\n Entry::Occupied(entry) => {\\n let expr = Expr::Assign(AssignExpr {\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(i))),\\n ..expr\\n });\\n let e = chain_assign!(entry, Box::new(expr));\\n\\n *e\\n }\\n _ => Expr::Assign(AssignExpr {\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(i))),\\n ..expr\\n }),\\n }\\n }\\n _ => {\\n let mut exprs = iter::once(Box::new(Expr::Assign(expr)))\\n .chain(\\n found\\n .into_iter()\\n .map(|var| Ident::new(var.0, var.1))\\n .filter_map(|i| {\\n let mut scope = folder.scope_mut();\\n let entry = match scope\\n .exported_vars\\n .entry((i.sym.clone(), i.span.ctxt()))\\n {\\n Entry::Occupied(entry) => entry,\\n _ => {\\n return None;\\n }\\n };\\n let e = chain_assign!(entry, Box::new(Expr::Ident(i)));\\n\\n // exports.name = x\\n Some(e)\\n }),\\n )\\n .collect::>();\\n if exprs.len() == 1 {\\n return *exprs.pop().unwrap();\\n }\\n\\n Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs,\\n })\\n }\\n }\\n }\\n _ => expr.fold_children_with(folder),\\n }\\n }\\n}\\n\\npub(super) fn make_require_call(\\n resolver: &Option<(R, FileName)>,\\n mark: Mark,\\n src: JsWord,\\n) -> Expr\\nwhere\\n R: ImportResolver,\\n{\\n let src = match resolver {\\n Some((resolver, base)) => resolver\\n .resolve_import(&base, &src)\\n .with_context(|| format!(\"failed to resolve import `{}`\", src))\\n .unwrap(),\\n None => src,\\n };\\n\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: quote_ident!(DUMMY_SP.apply_mark(mark), \"require\").as_callee(),\\n args: vec![Lit::Str(Str {\\n span: DUMMY_SP,\\n value: src,\\n has_escape: false,\\n kind: Default::default(),\\n })\\n .as_arg()],\\n\\n type_args: Default::default(),\\n })\\n}\\n\\npub(super) fn local_name_for_src(src: &JsWord) -> JsWord {\\n if !src.contains(\\'/\\') {\\n return format!(\"_{}\", src.to_camel_case()).into();\\n }\\n\\n format!(\"_{}\", src.split(\\'/\\').last().unwrap().to_camel_case()).into()\\n}\\n\\npub(super) fn define_property(args: Vec) -> Expr {\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: member_expr!(DUMMY_SP, Object.defineProperty).as_callee(),\\n args,\\n\\n type_args: Default::default(),\\n })\\n}\\n\\n/// Creates\\n///\\n///```js\\n/// \\n/// Object.defineProperty(exports, \\'__esModule\\', {\\n/// value: true\\n/// });\\n/// ```\\npub(super) fn define_es_module(exports: Ident) -> Stmt {\\n define_property(vec![\\n exports.as_arg(),\\n Lit::Str(quote_str!(\"__esModule\")).as_arg(),\\n ObjectLit {\\n span: DUMMY_SP,\\n props: vec![PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\"value\")),\\n value: Box::new(\\n Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n })\\n .into(),\\n ),\\n })))],\\n }\\n .as_arg(),\\n ])\\n .into_stmt()\\n}\\n\\npub(super) fn has_use_strict(stmts: &[ModuleItem]) -> bool {\\n if stmts.is_empty() {\\n return false;\\n }\\n\\n match &*stmts.first().unwrap() {\\n ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) => match &**expr {\\n Expr::Lit(Lit::Str(Str { ref value, .. })) => return &*value == \"use strict\",\\n _ => {}\\n },\\n _ => {}\\n }\\n\\n false\\n}\\n\\npub(super) fn use_strict() -> Stmt {\\n Lit::Str(quote_str!(\"use strict\")).into_stmt()\\n}\\n\\n/// Creates\\n///\\n/// ```js\\n/// exports.default = exports.foo = void 0;\\n/// ```\\npub(super) fn initialize_to_undefined(exports: Ident, initialized: FxHashSet) -> Box {\\n let mut rhs = undefined(DUMMY_SP);\\n\\n for name in initialized.into_iter() {\\n rhs = Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Expr(Box::new(\\n exports.clone().make_member(Ident::new(name, DUMMY_SP)),\\n )),\\n op: op!(\"=\"),\\n right: rhs,\\n }));\\n }\\n\\n rhs\\n}\\n\\npub(super) fn make_descriptor(get_expr: Box) -> ObjectLit {\\n let get_fn_body = Some(BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(get_expr),\\n })],\\n });\\n\\n ObjectLit {\\n span: DUMMY_SP,\\n props: vec![\\n PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\"enumerable\")),\\n value: Box::new(\\n Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n })\\n .into(),\\n ),\\n }))),\\n PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\"get\")),\\n value: Box::new(\\n FnExpr {\\n ident: None,\\n function: Function {\\n span: DUMMY_SP,\\n is_async: false,\\n is_generator: false,\\n decorators: Default::default(),\\n params: vec![],\\n body: get_fn_body,\\n return_type: Default::default(),\\n type_params: Default::default(),\\n },\\n }\\n .into(),\\n ),\\n }))),\\n ],\\n }\\n}\\n\\n/// Private `_exports` ident.\\npub(super) struct Exports(pub Ident);\\n\\nimpl Default for Exports {\\n fn default() -> Self {\\n Exports(private_ident!(\"_exports\"))\\n }\\n}\\n\\nmacro_rules! mark_as_nested {\\n () => {\\n mark_as_nested!(fold_function, Function);\\n mark_as_nested!(fold_constructor, Constructor);\\n mark_as_nested!(fold_setter_prop, SetterProp);\\n mark_as_nested!(fold_getter_prop, GetterProp);\\n };\\n\\n ($name:ident, $T:tt) => {\\n fn $name(&mut self, f: $T) -> $T {\\n let old = self.in_top_level;\\n self.in_top_level = false.into();\\n let f = f.fold_children_with(self);\\n self.in_top_level = old;\\n\\n f\\n }\\n };\\n}\\n',\n", + " 'content_id': 'a695d6016c0cb2a065ae1283e785e9f6d1b95e31',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/transforms/module/src/util.rs',\n", + " 'size': 35888,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4824031806803122,\n", + " 'avg_line_length': 22.996466431095406,\n", + " 'blob_id': '7447a769c18a5504f6f93b6538b97455f72c0b0a',\n", + " 'content': \"use super::Dce;\\nuse rustc_hash::FxHashSet;\\nuse swc_atoms::JsWord;\\nuse swc_common::DUMMY_SP;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, ExprExt, Id};\\nuse swc_ecma_visit::{noop_visit_type, Node, Visit, VisitWith};\\n\\npub(super) struct ImportDetector {\\n found: bool,\\n}\\n\\nimpl Visit for ImportDetector {\\n noop_visit_type!();\\n\\n fn visit_import_decl(&mut self, _: &ImportDecl, _: &dyn Node) {\\n self.found = true;\\n }\\n}\\n\\nimpl Dce<'_> {\\n pub(super) fn should_include(&mut self, node: &T) -> bool\\n where\\n T: for<'any> VisitWith> + VisitWith,\\n {\\n // Preserve imports if we are not in import dropping phase\\n if !self.decl_dropping_phase {\\n let mut v = ImportDetector { found: false };\\n\\n node.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n\\n if v.found {\\n return true;\\n }\\n }\\n\\n let mut v = SideEffectVisitor {\\n included: &mut self.included,\\n exports: self.config.used.as_ref().map(|v| &**v),\\n found: false,\\n };\\n\\n node.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n\\n v.found\\n }\\n}\\n\\nimpl SideEffectVisitor<'_> {\\n fn is_exported(&self, i: &JsWord) -> bool {\\n self.exports.is_some()\\n && self\\n .exports\\n .as_ref()\\n .unwrap()\\n .iter()\\n .any(|exported| exported.0 == *i)\\n }\\n}\\n\\npub(super) struct SideEffectVisitor<'a> {\\n included: &'a mut FxHashSet,\\n exports: Option<&'a [Id]>,\\n found: bool,\\n}\\n\\nimpl SideEffectVisitor<'_> {\\n fn include(&self, i: &Id) -> bool {\\n let id = i.to_id();\\n if self.included.contains(&id) {\\n return true;\\n }\\n\\n if let Some(exports) = self.exports {\\n if exports.contains(&id) {\\n return true;\\n }\\n }\\n\\n false\\n }\\n}\\n\\nimpl Visit for SideEffectVisitor<'_> {\\n noop_visit_type!();\\n\\n fn visit_expr(&mut self, node: &Expr, _: &dyn Node) {\\n if self.found || node.is_pure_callee() {\\n return;\\n }\\n\\n match node {\\n Expr::Lit(..) | Expr::PrivateName(..) | Expr::TsConstAssertion(..) => return,\\n\\n _ => {}\\n }\\n\\n node.visit_children_with(self)\\n }\\n\\n fn visit_var_declarator(&mut self, n: &VarDeclarator, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n if n.init.is_none() {\\n self.found = true;\\n return;\\n }\\n\\n n.visit_children_with(self);\\n }\\n\\n fn visit_assign_expr(&mut self, node: &AssignExpr, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n node.left.visit_with(node as _, self);\\n\\n match &*node.right {\\n Expr::Ident(..) => {\\n //TODO: Check for alias\\n }\\n right => right.visit_with(node as _, self),\\n }\\n }\\n\\n fn visit_break_stmt(&mut self, _: &BreakStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_call_expr(&mut self, node: &CallExpr, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n match node.callee {\\n ExprOrSuper::Expr(ref e) if e.is_pure_callee() => return,\\n _ => {}\\n }\\n\\n self.found = true;\\n }\\n\\n fn visit_continue_stmt(&mut self, _: &ContinueStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_do_while_stmt(&mut self, _: &DoWhileStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_export_decl(&mut self, _: &ExportDecl, _: &dyn Node) {\\n self.found = true\\n }\\n\\n fn visit_export_all(&mut self, _: &ExportAll, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_export_default_decl(&mut self, _: &ExportDefaultDecl, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_export_default_expr(&mut self, _: &ExportDefaultExpr, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_export_default_specifier(&mut self, _: &ExportDefaultSpecifier, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_expr_or_spread(&mut self, node: &ExprOrSpread, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n if node.spread.is_some() {\\n self.found = true;\\n }\\n\\n if !self.found {\\n node.expr.visit_with(node as _, self);\\n }\\n }\\n\\n fn visit_for_in_stmt(&mut self, _: &ForInStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_for_of_stmt(&mut self, _: &ForOfStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_for_stmt(&mut self, _: &ForStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_ident(&mut self, node: &Ident, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n self.found |= self.include(&node.to_id());\\n }\\n\\n fn visit_import_decl(&mut self, import: &ImportDecl, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n if import.specifiers.is_empty() {\\n self.found = true;\\n return;\\n }\\n\\n import.visit_children_with(self)\\n }\\n\\n fn visit_member_expr(&mut self, _: &MemberExpr, _: &dyn Node) {\\n self.found = true;\\n\\n // if self.found {\\n // return;\\n // }\\n\\n // node.obj.visit_with(self);\\n // if node.computed {\\n // node.prop.visit_with(self);\\n // }\\n }\\n\\n fn visit_named_export(&mut self, _: &NamedExport, _: &dyn Node) {\\n self.found = true\\n }\\n\\n fn visit_new_expr(&mut self, _: &NewExpr, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n self.found = true;\\n }\\n\\n fn visit_pat(&mut self, p: &Pat, _: &dyn Node) {\\n if self.found {\\n return;\\n }\\n\\n match p {\\n Pat::Ident(ref i) => {\\n if self.included.contains(&i.to_id()) || self.is_exported(&i.id.sym) {\\n self.found = true;\\n }\\n }\\n\\n Pat::Rest(..) => {\\n self.found = true;\\n }\\n Pat::Assign(..) | Pat::Expr(..) | Pat::Object(..) | Pat::Array(..) => {\\n p.visit_children_with(self)\\n }\\n Pat::Invalid(..) => {}\\n }\\n }\\n\\n fn visit_tagged_tpl(&mut self, _: &TaggedTpl, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_return_stmt(&mut self, _: &ReturnStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_throw_stmt(&mut self, _: &ThrowStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_while_stmt(&mut self, _: &WhileStmt, _: &dyn Node) {\\n self.found = true;\\n }\\n}\\n\",\n", + " 'content_id': 'cca07cd411ecf42d71984232336ae1b2e40e6a60',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 92,\n", + " 'path': '/ecmascript/transforms/optimization/src/simplify/dce/side_effect.rs',\n", + " 'size': 6791,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.40117776959882223,\n", + " 'avg_line_length': 28.857142857142858,\n", + " 'blob_id': 'b4dc364f5ee0233999d81061c85e683b3f6219a8',\n", + " 'content': 'use super::{load::TransformedModule, Bundler};\\nuse crate::{\\n bundler::chunk::merge::Ctx, load::Load, resolve::Resolve, util::IntoParallelIterator, Bundle,\\n};\\nuse ahash::AHashMap;\\nuse anyhow::{Context, Error};\\n#[cfg(feature = \"rayon\")]\\nuse rayon::iter::ParallelIterator;\\nuse rustc_hash::FxHashMap;\\nuse std::time::Instant;\\n\\nmod cjs;\\nmod computed_key;\\nmod merge;\\nmod plan;\\n\\n#[derive(Debug)]\\nstruct InternalEntry {}\\n\\n#[derive(Debug, Default)]\\nstruct State {}\\n\\nimpl Bundler<\\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// `entries` - Entry modules (provided by user) by it\\'s basename.\\n ///\\n /// # How it works\\n ///\\n /// For first, we load all dependencies and determine all entries.\\n pub(super) fn chunk(\\n &self,\\n entries: AHashMap,\\n ) -> Result, Error> {\\n let start = Instant::now();\\n let (plan, graph, cycles) = self.determine_entries(entries).context(\"failed to plan\")?;\\n let dur = Instant::now() - start;\\n tracing::debug!(\"Dependency analysis took {:?}\", dur);\\n\\n if cfg!(debug_assertions) {\\n for (i, id1) in plan.all.iter().enumerate() {\\n for (j, id2) in plan.all.iter().enumerate() {\\n if i == j {\\n continue;\\n }\\n\\n debug_assert_ne!(\\n id1, id2,\\n \"Dependency analysis created duplicate entries: {:?}\",\\n id1\\n )\\n }\\n }\\n }\\n\\n let ctx = Ctx {\\n graph,\\n cycles,\\n transitive_remap: Default::default(),\\n export_stars_in_wrapped: Default::default(),\\n };\\n\\n let start = Instant::now();\\n let mut all = (&*plan.all)\\n .into_par_iter()\\n .map(|id| -> Result<_, Error> {\\n self.run(|| {\\n // TODO: is_entry should be false if it\\'s dep of other entry.\\n let is_entry = plan.entries.contains_key(&id);\\n let module = self.get_for_merging(&ctx, *id, is_entry)?;\\n\\n Ok((*id, module))\\n })\\n })\\n .collect::, _>>()?;\\n\\n let dur = Instant::now() - start;\\n tracing::debug!(\"Module preparation took {:?}\", dur);\\n\\n let entries = all\\n .iter()\\n .filter_map(|(id, module)| {\\n if plan.entries.contains_key(&id) {\\n return Some((*id, module.clone()));\\n }\\n None\\n })\\n .collect::>();\\n\\n let merged: Vec<_> = if entries.len() == 1 {\\n entries\\n .into_iter()\\n .map(|(id, mut entry)| {\\n self.merge_into_entry(&ctx, id, &mut entry, &mut all);\\n\\n tracing::debug!(\"Merged `{}` and it\\'s dep into an entry\", id);\\n\\n (id, entry)\\n })\\n .map(|(id, module)| {\\n let kind = plan\\n .entries\\n .get(&id)\\n .unwrap_or_else(|| {\\n unreachable!(\"Plan does not contain bundle kind for {:?}\", id)\\n })\\n .clone();\\n Bundle {\\n kind,\\n id,\\n module: module.into(),\\n }\\n })\\n .collect()\\n } else {\\n entries\\n .into_iter()\\n .map(|(id, mut entry)| {\\n let mut a = all.clone();\\n self.merge_into_entry(&ctx, id, &mut entry, &mut a);\\n\\n tracing::debug!(\"Merged `{}` and it\\'s dep into an entry\", id);\\n\\n (id, entry)\\n })\\n .map(|(id, module)| {\\n let kind = plan\\n .entries\\n .get(&id)\\n .unwrap_or_else(|| {\\n unreachable!(\"Plan does not contain bundle kind for {:?}\", id)\\n })\\n .clone();\\n Bundle {\\n kind,\\n id,\\n module: module.into(),\\n }\\n })\\n .collect()\\n };\\n\\n Ok(merged)\\n }\\n}\\n\\n#[cfg(test)]\\nmod tests {\\n use super::*;\\n use crate::bundler::tests::suite;\\n use swc_common::FileName;\\n\\n #[test]\\n fn cjs_chunk() {\\n suite()\\n .file(\\n \"main.js\",\\n \"\\n require(\\'./a\\');\\n require(\\'./b\\');\\n \",\\n )\\n .file(\"a.js\", \"require(\\'./common\\')\")\\n .file(\"b.js\", \"require(\\'./common\\')\")\\n .file(\"common.js\", r#\"console.log(\\'foo\\')\"#)\\n .run(|t| {\\n let module = t\\n .bundler\\n .load_transformed(&FileName::Real(\"main.js\".into()))?\\n .unwrap();\\n let mut entries = AHashMap::default();\\n entries.insert(\"main.js\".to_string(), module);\\n\\n let chunked = t.bundler.chunk(entries)?;\\n assert_eq!(chunked.len(), 1);\\n\\n Ok(())\\n });\\n }\\n}\\n',\n", + " 'content_id': '6e992941eec5cee9cbba74ea11597c26004a0f0b',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 97,\n", + " 'path': '/bundler/src/bundler/chunk/mod.rs',\n", + " 'size': 5434,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5159420289855072,\n", + " 'avg_line_length': 24.450819672131146,\n", + " 'blob_id': '9ec2ae02a3670f90c4c3a1da1d5157d2c5045143',\n", + " 'content': 'use crate::{\\n bundler::load::TransformedModule, dep_graph::ModuleGraph, BundleKind, Bundler, Load, ModuleId,\\n Resolve,\\n};\\nuse ahash::AHashMap;\\nuse anyhow::{bail, Error};\\nuse rustc_hash::{FxHashMap, FxHashSet};\\n\\n#[cfg(test)]\\nmod tests;\\n\\n#[derive(Debug, Default)]\\nstruct PlanBuilder {\\n /// `(src, dst)`\\n tracked: FxHashSet<(ModuleId, ModuleId)>,\\n\\n graph: ModuleGraph,\\n cycles: Vec>,\\n all: Vec,\\n\\n kinds: FxHashMap,\\n}\\n\\n#[derive(Debug, Default)]\\npub(super) struct Plan {\\n pub entries: FxHashMap,\\n\\n /// Id of all modules.\\n pub all: Vec,\\n}\\n\\nimpl Bundler<\\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n pub(super) fn determine_entries(\\n &self,\\n entries: AHashMap,\\n ) -> Result<(Plan, ModuleGraph, Vec>), Error> {\\n let mut builder = PlanBuilder::default();\\n\\n for (name, module) in entries {\\n match builder.kinds.insert(module.id, BundleKind::Named { name }) {\\n Some(v) => bail!(\"Multiple entries with same input path detected: {:?}\", v),\\n None => {}\\n }\\n\\n self.add_to_graph(&mut builder, module.id, &mut vec![module.id]);\\n }\\n\\n // dbg!(&builder.cycles);\\n\\n Ok((\\n Plan {\\n entries: builder.kinds,\\n all: builder.all,\\n },\\n builder.graph,\\n builder.cycles,\\n ))\\n }\\n\\n fn add_to_graph(\\n &self,\\n builder: &mut PlanBuilder,\\n module_id: ModuleId,\\n path: &mut Vec,\\n ) {\\n if cfg!(test) {\\n tracing::debug!(\"Adding {:?} to the graph (path = {:?})\", module_id, path);\\n }\\n let visited = builder.all.contains(&module_id);\\n // dbg!(visited);\\n // dbg!(&path);\\n let cycle_rpos = if visited {\\n path.iter().rposition(|v| *v == module_id)\\n } else {\\n None\\n };\\n\\n if let Some(rpos) = cycle_rpos {\\n let cycle = path[rpos..].to_vec();\\n tracing::debug!(\"Found cycle: {:?}\", cycle);\\n builder.cycles.push(cycle);\\n }\\n\\n let prev_last = *path.last().unwrap();\\n // Prevent infinite recursion.\\n if !builder.tracked.insert((prev_last, module_id)) {\\n return;\\n }\\n\\n path.push(module_id);\\n\\n if !visited {\\n builder.all.push(module_id);\\n }\\n builder.graph.add_node(module_id);\\n\\n let m = self\\n .scope\\n .get_module(module_id)\\n .expect(\"failed to get module\");\\n\\n for (src, _) in m\\n .imports\\n .specifiers\\n .iter()\\n .chain(m.exports.reexports.iter())\\n {\\n tracing::debug!(\"Dep: {} -> {}\", module_id, src.module_id);\\n\\n builder.graph.add_edge(module_id, src.module_id, ());\\n\\n self.add_to_graph(builder, src.module_id, path);\\n }\\n\\n let res = path.pop();\\n debug_assert_eq!(res, Some(module_id));\\n }\\n}\\n',\n", + " 'content_id': '105b177edbc1eeeb693ac6024b4e7a31009a36f1',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/bundler/src/bundler/chunk/plan/mod.rs',\n", + " 'size': 3105,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3825659596482152,\n", + " 'avg_line_length': 31.578651685393258,\n", + " 'blob_id': '804f9414db3116e52c9967c4863b23c1f0a09ef9',\n", + " 'content': 'use super::Bundler;\\nuse crate::{load::Load, resolve::Resolve};\\nuse anyhow::{Context, Error};\\nuse retain_mut::RetainMut;\\nuse rustc_hash::{FxHashMap, FxHashSet};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{sync::Lrc, FileName, Mark, Spanned, SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{find_ids, ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};\\n\\n#[cfg(test)]\\nmod tests;\\n\\nimpl Bundler<\\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// This method de-globs imports if possible and colorizes imported values.\\n pub(super) fn extract_import_info(\\n &self,\\n path: &FileName,\\n module: &mut Module,\\n module_local_mark: Mark,\\n ) -> RawImports {\\n self.run(|| {\\n let mut v = ImportHandler {\\n module_ctxt: SyntaxContext::empty().apply_mark(module_local_mark),\\n path,\\n bundler: self,\\n top_level: false,\\n info: Default::default(),\\n usages: Default::default(),\\n imported_idents: Default::default(),\\n deglob_phase: false,\\n idents_to_deglob: Default::default(),\\n in_obj_of_member: false,\\n };\\n module.body.visit_mut_with(&mut v);\\n v.deglob_phase = true;\\n module.body.visit_mut_with(&mut v);\\n\\n v.info\\n })\\n }\\n\\n pub(super) fn resolve(\\n &self,\\n base: &FileName,\\n module_specifier: &str,\\n ) -> Result, Error> {\\n self.run(|| {\\n let path = self\\n .resolver\\n .resolve(base, module_specifier)\\n .with_context(|| format!(\"failed to resolve {} from {}\", module_specifier, base))?;\\n\\n let path = Lrc::new(path);\\n\\n Ok(path)\\n })\\n }\\n}\\n\\n#[derive(Debug, Default)]\\npub(super) struct RawImports {\\n /// Unconditional imports. This includes require on top level.\\n pub imports: Vec,\\n\\n /// Non-top-level imports.\\n ///\\n /// # Example\\n ///\\n /// ```js\\n /// try{\\n /// const { watch } = require(\\'watcher\\');\\n /// } catch (e) {\\n /// }\\n /// ```\\n pub lazy_imports: Vec,\\n pub dynamic_imports: Vec,\\n\\n /// Contains namespace imports accessed with computed key.\\n ///\\n ///\\n /// e.g.\\n ///\\n ///```js\\n /// import * as foo from \\'./foo\\';\\n /// function bar() {}\\n /// foo[bar()]\\n /// ```\\n pub forced_ns: FxHashSet,\\n}\\n\\n/// This type implements two operation (analysis, deglobbing) to reduce binary\\n/// size.\\nstruct ImportHandler<\\'a, \\'b, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// The [SyntaxContext] for the top level module items.\\n //// The top level module items includes imported bindings.\\n module_ctxt: SyntaxContext,\\n path: &\\'a FileName,\\n bundler: &\\'a Bundler<\\'b, L, R>,\\n top_level: bool,\\n info: RawImports,\\n\\n /// HashMap from the local identifier of a namespace import to used\\n /// properties.\\n usages: FxHashMap>,\\n\\n /// While deglobbing, we also marks imported identifiers.\\n imported_idents: FxHashMap,\\n\\n deglob_phase: bool,\\n idents_to_deglob: FxHashSet,\\n\\n /// `true` while folding objects of a member expression.\\n ///\\n /// This is used to distinguish usage of `a` in `console.log(a)` and\\n /// `a.join()`.\\n in_obj_of_member: bool,\\n}\\n\\nimpl RawImports {\\n fn insert(&mut self, import: &ImportDecl) {\\n for prev in self.imports.iter_mut() {\\n if prev.src.value == import.src.value {\\n prev.specifiers.extend(import.specifiers.clone());\\n return;\\n }\\n }\\n\\n self.imports.push(import.clone());\\n }\\n}\\n\\nimpl ImportHandler<\\'_, \\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// Retursn (local, export)\\n fn ctxt_for(&self, src: &JsWord) -> Option<(SyntaxContext, SyntaxContext)> {\\n // Don\\'t apply mark if it\\'s a core module.\\n if self\\n .bundler\\n .config\\n .external_modules\\n .iter()\\n .any(|v| v == src)\\n {\\n return None;\\n }\\n let path = self.bundler.resolve(self.path, src).ok()?;\\n let (_, local_mark, export_mark) = self.bundler.scope.module_id_gen.gen(&path);\\n\\n Some((\\n SyntaxContext::empty().apply_mark(local_mark),\\n SyntaxContext::empty().apply_mark(export_mark),\\n ))\\n }\\n\\n fn mark_as_wrapping_required(&self, src: &JsWord) {\\n // Don\\'t apply mark if it\\'s a core module.\\n if self\\n .bundler\\n .config\\n .external_modules\\n .iter()\\n .any(|v| v == src)\\n {\\n return;\\n }\\n let path = self.bundler.resolve(self.path, src);\\n let path = match path {\\n Ok(v) => v,\\n Err(_) => return,\\n };\\n let (id, _, _) = self.bundler.scope.module_id_gen.gen(&path);\\n\\n self.bundler.scope.mark_as_wrapping_required(id);\\n }\\n\\n fn mark_as_cjs(&self, src: &JsWord) {\\n let path = self.bundler.resolve(self.path, src);\\n let path = match path {\\n Ok(v) => v,\\n Err(_) => return,\\n };\\n let (id, _, _) = self.bundler.scope.module_id_gen.gen(&path);\\n\\n self.bundler.scope.mark_as_cjs(id);\\n }\\n\\n fn add_forced_ns_for(&mut self, id: Id) {\\n self.idents_to_deglob.remove(&id);\\n self.imported_idents.remove(&id);\\n self.usages.remove(&id);\\n\\n if let Some(src) = self\\n .info\\n .imports\\n .iter()\\n .find(|import| {\\n import.specifiers.iter().any(|specifier| match specifier {\\n ImportSpecifier::Namespace(ns) => {\\n ns.local.sym == id.0 && ns.local.span.ctxt == id.1\\n }\\n _ => false,\\n })\\n })\\n .map(|import| import.src.value.clone())\\n {\\n self.info.forced_ns.insert(src);\\n return;\\n }\\n }\\n\\n fn find_require(&mut self, e: &mut Expr) {\\n match e {\\n Expr::Call(e) if e.args.len() == 1 => {\\n let src = match e.args.first().unwrap() {\\n ExprOrSpread { spread: None, expr } => match &**expr {\\n Expr::Lit(Lit::Str(s)) => s,\\n _ => return,\\n },\\n _ => return,\\n };\\n\\n match &mut e.callee {\\n ExprOrSuper::Expr(callee)\\n if self.bundler.config.require\\n && match &**callee {\\n Expr::Ident(Ident {\\n sym: js_word!(\"require\"),\\n ..\\n }) => true,\\n _ => false,\\n } =>\\n {\\n match &mut **callee {\\n Expr::Ident(i) => {\\n self.mark_as_cjs(&src.value);\\n if let Some((_, export_ctxt)) = self.ctxt_for(&src.value) {\\n i.span = i.span.with_ctxt(export_ctxt);\\n }\\n }\\n _ => {}\\n }\\n\\n let span = callee.span();\\n\\n let decl = ImportDecl {\\n span,\\n specifiers: vec![],\\n src: src.clone(),\\n type_only: false,\\n asserts: None,\\n };\\n\\n if self.top_level {\\n self.info.insert(&decl);\\n return;\\n }\\n\\n self.info.lazy_imports.push(decl);\\n return;\\n }\\n\\n // TODO: Uncomment this after implementing an option to make swc_bundler\\n // includes dynamic imports\\n //\\n //\\n // ExprOrSuper::Expr(ref e) => match &**e {\\n // Expr::Ident(Ident {\\n // sym: js_word!(\"import\"),\\n // ..\\n // }) => {\\n // self.info.dynamic_imports.push(src.clone());\\n // }\\n // _ => {}\\n // },\\n _ => {}\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn analyze_usage(&mut self, e: &mut Expr) {\\n match e {\\n Expr::Member(e) => match &e.obj {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(obj) => match &**obj {\\n Expr::Ident(obj) => {\\n if !self.imported_idents.contains_key(&obj.to_id()) {\\n // If it\\'s not imported, just abort the usage analysis.\\n return;\\n }\\n\\n if e.computed {\\n // If a module is accessed with unknown key, we should import\\n // everyrthing from it.\\n self.add_forced_ns_for(obj.to_id());\\n return;\\n }\\n\\n // Store usages of obj\\n let import = self.info.imports.iter().find(|import| {\\n for s in &import.specifiers {\\n match s {\\n ImportSpecifier::Namespace(n) => {\\n return obj.sym == n.local.sym\\n && (obj.span.ctxt == self.module_ctxt\\n || obj.span.ctxt == n.local.span.ctxt)\\n }\\n _ => {}\\n }\\n }\\n\\n false\\n });\\n let import = match import {\\n Some(v) => v,\\n None => return,\\n };\\n\\n let mark = self.ctxt_for(&import.src.value);\\n let exported_ctxt = match mark {\\n None => return,\\n Some(ctxts) => ctxts.1,\\n };\\n let prop = match &*e.prop {\\n Expr::Ident(i) => {\\n let mut i = i.clone();\\n i.span = i.span.with_ctxt(exported_ctxt);\\n i\\n }\\n _ => unreachable!(\\n \"Non-computed member expression with property other than ident is \\\\\\n invalid\"\\n ),\\n };\\n\\n self.usages\\n .entry(obj.to_id())\\n .or_default()\\n .push(prop.to_id());\\n }\\n _ => {}\\n },\\n },\\n _ => {}\\n }\\n }\\n\\n fn try_deglob(&mut self, e: &mut Expr) {\\n let me = match e {\\n Expr::Member(e) => e,\\n _ => return,\\n };\\n if me.computed {\\n return;\\n }\\n\\n let obj = match &me.obj {\\n ExprOrSuper::Super(_) => return,\\n ExprOrSuper::Expr(e) => e,\\n };\\n\\n let obj = match &**obj {\\n Expr::Ident(obj) => obj,\\n _ => return,\\n };\\n\\n let usages = self.usages.get(&obj.to_id());\\n\\n match usages {\\n Some(..) => {}\\n _ => return,\\n };\\n\\n let mut prop = match &*me.prop {\\n Expr::Ident(v) => v.clone(),\\n _ => return,\\n };\\n prop.span.ctxt = self.imported_idents.get(&obj.to_id()).copied().unwrap();\\n\\n *e = Expr::Ident(prop);\\n }\\n}\\n\\nimpl VisitMut for ImportHandler<\\'_, \\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n noop_visit_mut_type!();\\n\\n fn visit_mut_import_decl(&mut self, import: &mut ImportDecl) {\\n // Ignore if it\\'s a core module.\\n if self\\n .bundler\\n .config\\n .external_modules\\n .contains(&import.src.value)\\n {\\n return;\\n }\\n\\n if !self.deglob_phase {\\n if let Some((_, export_ctxt)) = self.ctxt_for(&import.src.value) {\\n // Firstly we attach proper syntax contexts.\\n import.span = import.span.with_ctxt(export_ctxt);\\n\\n // Then we store list of imported identifiers.\\n for specifier in &mut import.specifiers {\\n match specifier {\\n ImportSpecifier::Named(n) => {\\n self.imported_idents.insert(n.local.to_id(), export_ctxt);\\n match &mut n.imported {\\n Some(imported) => {\\n imported.span.ctxt = export_ctxt;\\n }\\n None => {\\n let mut imported: Ident = n.local.clone();\\n imported.span.ctxt = export_ctxt;\\n n.imported = Some(imported);\\n }\\n }\\n }\\n ImportSpecifier::Default(n) => {\\n self.imported_idents\\n .insert(n.local.to_id(), n.local.span.ctxt);\\n }\\n ImportSpecifier::Namespace(n) => {\\n self.imported_idents.insert(n.local.to_id(), export_ctxt);\\n }\\n }\\n }\\n }\\n\\n self.info.insert(&import);\\n return;\\n }\\n\\n // Now we are in deglobbing phase.\\n\\n // We cannot deglob this.\\n if self.info.forced_ns.contains(&import.src.value) {\\n return;\\n }\\n\\n // deglob namespace imports\\n if import.specifiers.len() == 1 {\\n match &import.specifiers[0] {\\n ImportSpecifier::Namespace(ns) => {\\n //\\n let specifiers = self\\n .usages\\n .get(&ns.local.to_id())\\n .cloned()\\n .map(|ids| {\\n //\\n let specifiers: Vec<_> = ids\\n .into_iter()\\n .map(|id| {\\n self.idents_to_deglob.insert(id.clone());\\n ImportSpecifier::Named(ImportNamedSpecifier {\\n span: DUMMY_SP,\\n local: Ident::new(id.0, DUMMY_SP.with_ctxt(id.1)),\\n imported: None,\\n is_type_only: false,\\n })\\n })\\n .collect();\\n\\n for import_info in &mut self.info.imports {\\n if import_info.src != import.src {\\n continue;\\n }\\n\\n import_info.specifiers.extend(specifiers.clone());\\n }\\n\\n specifiers\\n })\\n .unwrap_or_else(Vec::new);\\n\\n if !specifiers.is_empty() {\\n import.specifiers = specifiers;\\n return;\\n }\\n\\n // We failed to found property usage.\\n self.info.forced_ns.insert(import.src.value.clone());\\n }\\n\\n _ => {}\\n }\\n }\\n }\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n e.visit_mut_children_with(self);\\n\\n if !self.deglob_phase {\\n // Firstly, we check for usages of imported namespaces.\\n // Code like below are handled by this check.\\n //\\n // import * as log from \\'./log\\';\\n // console.log(log)\\n // console.log(log.getLogger())\\n if !self.in_obj_of_member {\\n match &e {\\n Expr::Ident(i) => {\\n if !self.in_obj_of_member {\\n self.add_forced_ns_for(i.to_id());\\n return;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n self.analyze_usage(e);\\n self.find_require(e);\\n } else {\\n self.try_deglob(e);\\n }\\n }\\n\\n fn visit_mut_member_expr(&mut self, e: &mut MemberExpr) {\\n let old = self.in_obj_of_member;\\n self.in_obj_of_member = true;\\n e.obj.visit_mut_with(self);\\n\\n if e.computed {\\n self.in_obj_of_member = false;\\n e.prop.visit_mut_with(self);\\n }\\n\\n self.in_obj_of_member = old;\\n }\\n\\n fn visit_mut_stmts(&mut self, items: &mut Vec) {\\n self.top_level = false;\\n items.visit_mut_children_with(self)\\n }\\n\\n fn visit_mut_export_named_specifier(&mut self, s: &mut ExportNamedSpecifier) {\\n match &s.exported {\\n Some(exported) => {\\n debug_assert_eq!(\\n exported.span.ctxt, self.module_ctxt,\\n \"Exported names should have same (local) context as top-level module \\\\\\n items\\\\n{}\\\\n{:?}\",\\n self.path, s\\n );\\n }\\n None => {\\n let exported =\\n Ident::new(s.orig.sym.clone(), s.orig.span.with_ctxt(self.module_ctxt));\\n s.exported = Some(exported);\\n }\\n }\\n }\\n\\n /// ```js\\n /// const { readFile } = required(\\'fs\\');\\n /// ```\\n ///\\n /// is treated as\\n ///\\n /// ```js\\n /// import { readFile } from \\'fs\\';\\n /// ```\\n fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {\\n node.visit_mut_children_with(self);\\n\\n match &mut node.init {\\n Some(init) => match &mut **init {\\n Expr::Call(CallExpr {\\n span,\\n callee: ExprOrSuper::Expr(ref mut callee),\\n ref args,\\n ..\\n }) if self.bundler.config.require\\n && match &**callee {\\n Expr::Ident(Ident {\\n sym: js_word!(\"require\"),\\n ..\\n }) => true,\\n _ => false,\\n }\\n && args.len() == 1 =>\\n {\\n let span = *span;\\n let src = match args.first().unwrap() {\\n ExprOrSpread { spread: None, expr } => match &**expr {\\n Expr::Lit(Lit::Str(s)) => s.clone(),\\n _ => return,\\n },\\n _ => return,\\n };\\n // Ignore core modules.\\n if self.bundler.config.external_modules.contains(&src.value) {\\n return;\\n }\\n\\n self.mark_as_cjs(&src.value);\\n\\n match &mut **callee {\\n Expr::Ident(i) => {\\n if let Some((_, export_ctxt)) = self.ctxt_for(&src.value) {\\n i.span = i.span.with_ctxt(export_ctxt);\\n }\\n }\\n _ => {}\\n }\\n\\n let ids: Vec = find_ids(&node.name);\\n\\n let decl = ImportDecl {\\n span,\\n specifiers: ids\\n .into_iter()\\n .map(|ident| {\\n ImportSpecifier::Named(ImportNamedSpecifier {\\n span,\\n local: ident,\\n imported: None,\\n is_type_only: false,\\n })\\n })\\n .collect(),\\n src,\\n type_only: false,\\n asserts: None,\\n };\\n\\n // if self.top_level {\\n // self.info.imports.push(decl);\\n // node.init = None;\\n // node.name = Pat::Invalid(Invalid { span: DUMMY_SP });\\n // return node;\\n // }\\n\\n self.info.lazy_imports.push(decl);\\n }\\n\\n _ => {}\\n },\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_module_items(&mut self, items: &mut Vec) {\\n self.top_level = true;\\n items.visit_mut_children_with(self);\\n\\n items.retain_mut(|item| match item {\\n ModuleItem::Stmt(Stmt::Empty(..)) => false,\\n ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {\\n var.decls.retain(|d| match d.name {\\n Pat::Invalid(..) => false,\\n _ => true,\\n });\\n\\n if var.decls.is_empty() {\\n false\\n } else {\\n true\\n }\\n }\\n\\n _ => true,\\n });\\n\\n if self.deglob_phase {\\n let mut wrapping_required = vec![];\\n for import in self.info.imports.iter_mut() {\\n let use_ns = self.info.forced_ns.contains(&import.src.value)\\n || self\\n .bundler\\n .config\\n .external_modules\\n .contains(&import.src.value);\\n\\n if use_ns {\\n wrapping_required.push(import.src.value.clone());\\n } else {\\n // De-glob namespace imports\\n import.specifiers.retain(|s| match s {\\n ImportSpecifier::Namespace(_) => false,\\n _ => true,\\n });\\n }\\n }\\n\\n for id in wrapping_required {\\n self.mark_as_wrapping_required(&id);\\n }\\n }\\n }\\n}\\n',\n", + " 'content_id': '30de60834906b301b55b6c1630ce361eec45f2c9',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/bundler/src/bundler/import/mod.rs',\n", + " 'size': 23196,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.43646288209606987,\n", + " 'avg_line_length': 28.171974522292995,\n", + " 'blob_id': 'f10106770793c3052ce23d510b65696ecc8da8d7',\n", + " 'content': 'use crate::id::Id;\\nuse rustc_hash::FxHashMap;\\nuse swc_atoms::js_word;\\nuse swc_common::util::take::Take;\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::private_ident;\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};\\n\\n#[derive(Default)]\\npub struct KeywordRenamer {\\n renamed: FxHashMap,\\n}\\n\\nimpl KeywordRenamer {\\n /// Returns `Some(new_ident)` if it should be renamed.\\n fn renamed(&mut self, id: &Ident) -> Option {\\n if id.sym == js_word!(\"import\") {\\n return None;\\n }\\n\\n if !(id.is_reserved() || id.is_reserved_in_strict_mode(true) || id.is_reserved_in_es3()) {\\n return None;\\n }\\n\\n Some(\\n self.renamed\\n .entry(id.into())\\n .or_insert_with(|| private_ident!(id.span, format!(\"__{}\", id.sym)))\\n .clone(),\\n )\\n }\\n}\\n\\nimpl VisitMut for KeywordRenamer {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_class_decl(&mut self, c: &mut ClassDecl) {\\n c.class.visit_mut_with(self);\\n if let Some(renamed) = self.renamed(&c.ident) {\\n c.ident = renamed;\\n }\\n }\\n\\n fn visit_mut_class_prop(&mut self, n: &mut ClassProp) {\\n if n.computed {\\n n.key.visit_mut_with(self);\\n }\\n\\n n.decorators.visit_mut_with(self);\\n n.value.visit_mut_with(self);\\n }\\n\\n fn visit_mut_export_named_specifier(&mut self, n: &mut ExportNamedSpecifier) {\\n if let Some(renamed) = self.renamed(&n.orig) {\\n n.orig = renamed;\\n }\\n }\\n\\n fn visit_mut_expr(&mut self, n: &mut Expr) {\\n match n {\\n Expr::Ident(n) => {\\n if let Some(renamed) = self.renamed(&n) {\\n *n = renamed;\\n }\\n return;\\n }\\n _ => {}\\n }\\n\\n n.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_fn_decl(&mut self, f: &mut FnDecl) {\\n f.function.visit_mut_with(self);\\n if let Some(renamed) = self.renamed(&f.ident) {\\n f.ident = renamed;\\n }\\n }\\n\\n fn visit_mut_member_expr(&mut self, n: &mut MemberExpr) {\\n n.obj.visit_mut_with(self);\\n\\n if n.computed {\\n n.prop.visit_mut_with(self)\\n }\\n }\\n\\n fn visit_mut_object_pat_prop(&mut self, n: &mut ObjectPatProp) {\\n n.visit_mut_children_with(self);\\n\\n match n {\\n ObjectPatProp::Assign(pat) => {\\n if let Some(renamed) = self.renamed(&pat.key) {\\n match &mut pat.value {\\n Some(default) => {\\n *n = ObjectPatProp::KeyValue(KeyValuePatProp {\\n key: PropName::Ident(pat.key.take()),\\n value: Box::new(Pat::Assign(AssignPat {\\n span: pat.span,\\n left: Box::new(Pat::Ident(renamed.into())),\\n right: default.take(),\\n type_ann: None,\\n })),\\n });\\n }\\n None => {\\n *n = ObjectPatProp::KeyValue(KeyValuePatProp {\\n key: PropName::Ident(pat.key.take()),\\n value: Box::new(Pat::Ident(renamed.into())),\\n })\\n }\\n }\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_pat(&mut self, n: &mut Pat) {\\n match n {\\n Pat::Ident(n) => {\\n if let Some(renamed) = self.renamed(&n.id) {\\n *n = renamed.into();\\n }\\n\\n return;\\n }\\n _ => {}\\n }\\n n.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_private_prop(&mut self, n: &mut PrivateProp) {\\n if n.computed {\\n n.key.visit_mut_with(self);\\n }\\n\\n n.decorators.visit_mut_with(self);\\n n.value.visit_mut_with(self);\\n }\\n\\n fn visit_mut_prop(&mut self, n: &mut Prop) {\\n match n {\\n Prop::Shorthand(i) => {\\n if let Some(renamed) = self.renamed(&i) {\\n *n = Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(i.clone()),\\n value: Box::new(Expr::Ident(renamed)),\\n });\\n }\\n }\\n _ => {\\n n.visit_mut_children_with(self);\\n }\\n }\\n }\\n}\\n',\n", + " 'content_id': '69ba09b03ef1394b967f53524081dc1240417926',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/bundler/src/bundler/keywords.rs',\n", + " 'size': 4580,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.49534570890503093,\n", + " 'avg_line_length': 27.769349845201237,\n", + " 'blob_id': 'cf69d7af0a34d86a75e5e59103c843e867dae3d7',\n", + " 'content': '#![allow(dead_code)]\\n#![recursion_limit = \"256\"]\\n\\npub use self::{transform_data::Feature, version::Version};\\nuse dashmap::DashMap;\\nuse once_cell::sync::Lazy;\\nuse rustc_hash::{FxHashMap, FxHashSet};\\nuse serde::{Deserialize, Serialize};\\nuse st_map::StaticMap;\\nuse std::{\\n path::{Path, PathBuf},\\n process::Command,\\n};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{chain, comments::Comments, FromVariant, Mark, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms::{\\n compat::{bugfixes, es2015, es2016, es2017, es2018, es2019, es2020, es2021, es3},\\n pass::{noop, Optional},\\n};\\nuse swc_ecma_utils::prepend_stmts;\\nuse swc_ecma_visit::{Fold, FoldWith, VisitWith};\\n\\n#[macro_use]\\nmod util;\\nmod corejs2;\\nmod corejs3;\\nmod regenerator;\\nmod transform_data;\\nmod version;\\n\\npub fn preset_env(global_mark: Mark, comments: Option, c: Config) -> impl Fold\\nwhere\\n C: Comments,\\n{\\n let loose = c.loose;\\n let targets: Versions =\\n targets_to_versions(c.targets, &c.path).expect(\"failed to parse targets\");\\n let is_any_target = targets.is_any_target();\\n\\n let (include, included_modules) = FeatureOrModule::split(c.include);\\n let (exclude, excluded_modules) = FeatureOrModule::split(c.exclude);\\n\\n let pass = noop();\\n\\n macro_rules! should_enable {\\n ($feature:ident, $default:expr) => {{\\n let f = transform_data::Feature::$feature;\\n !exclude.contains(&f)\\n && (c.force_all_transforms\\n || (is_any_target\\n || include.contains(&f)\\n || f.should_enable(targets, c.bugfixes, $default)))\\n }};\\n }\\n\\n macro_rules! add {\\n ($prev:expr, $feature:ident, $pass:expr) => {{\\n add!($prev, $feature, $pass, false)\\n }};\\n ($prev:expr, $feature:ident, $pass:expr, $default:expr) => {{\\n let f = transform_data::Feature::$feature;\\n\\n let enable = should_enable!($feature, $default);\\n if c.debug {\\n println!(\"{}: {:?}\", f.as_str(), enable);\\n }\\n chain!($prev, Optional::new($pass, enable))\\n }};\\n }\\n\\n // Bugfixes\\n let pass = add!(pass, BugfixEdgeDefaultParam, bugfixes::edge_default_param());\\n let pass = add!(\\n pass,\\n BugfixAsyncArrowsInClass,\\n bugfixes::async_arrows_in_class()\\n );\\n let pass = add!(\\n pass,\\n BugfixTaggedTemplateCaching,\\n bugfixes::template_literal_caching()\\n );\\n\\n // Proposals\\n\\n // ES2021\\n let pass = add!(\\n pass,\\n LogicalAssignmentOperators,\\n es2021::logical_assignments()\\n );\\n\\n // ES2020\\n\\n let pass = add!(pass, ExportNamespaceFrom, es2020::export_namespace_from());\\n let pass = add!(pass, NullishCoalescing, es2020::nullish_coalescing());\\n\\n let pass = add!(pass, OptionalChaining, es2020::optional_chaining());\\n let pass = add!(\\n pass,\\n ClassProperties,\\n es2020::class_properties(es2020::class_properties::Config { loose })\\n );\\n\\n // ES2019\\n let pass = add!(pass, OptionalCatchBinding, es2019::optional_catch_binding());\\n\\n // ES2018\\n let pass = add!(pass, ObjectRestSpread, es2018::object_rest_spread());\\n\\n // ES2017\\n let pass = add!(pass, AsyncToGenerator, es2017::async_to_generator());\\n\\n // ES2016\\n let pass = add!(pass, ExponentiationOperator, es2016::exponentation());\\n\\n // ES2015\\n let pass = add!(pass, BlockScopedFunctions, es2015::block_scoped_functions());\\n let pass = add!(pass, TemplateLiterals, es2015::template_literal(), true);\\n let pass = add!(pass, Classes, es2015::classes(comments));\\n let pass = add!(\\n pass,\\n Spread,\\n es2015::spread(es2015::spread::Config { loose }),\\n true\\n );\\n let pass = add!(pass, FunctionName, es2015::function_name());\\n let pass = add!(pass, ArrowFunctions, es2015::arrow());\\n let pass = add!(pass, DuplicateKeys, es2015::duplicate_keys());\\n let pass = add!(pass, StickyRegex, es2015::sticky_regex());\\n // TODO: InstanceOf,\\n let pass = add!(pass, TypeOfSymbol, es2015::typeof_symbol());\\n let pass = add!(pass, ShorthandProperties, es2015::shorthand());\\n let pass = add!(pass, Parameters, es2015::parameters());\\n let pass = add!(\\n pass,\\n ForOf,\\n es2015::for_of(es2015::for_of::Config {\\n assume_array: loose\\n }),\\n true\\n );\\n let pass = add!(\\n pass,\\n ComputedProperties,\\n es2015::computed_properties(),\\n true\\n );\\n let pass = add!(\\n pass,\\n Destructuring,\\n es2015::destructuring(es2015::destructuring::Config { loose }),\\n true\\n );\\n let pass = add!(pass, Regenerator, es2015::regenerator(global_mark), true);\\n let pass = add!(pass, BlockScoping, es2015::block_scoping(), true);\\n\\n // TODO:\\n // Literals,\\n // ObjectSuper,\\n // DotAllRegex,\\n // UnicodeRegex,\\n // NewTarget,\\n // AsyncGeneratorFunctions,\\n // UnicodePropertyRegex,\\n // JsonStrings,\\n // NamedCapturingGroupsRegex,\\n\\n // ES 3\\n let pass = add!(pass, PropertyLiterals, es3::property_literals());\\n let pass = add!(\\n pass,\\n MemberExpressionLiterals,\\n es3::member_expression_literals()\\n );\\n let pass = add!(pass, ReservedWords, es3::reserved_words(c.dynamic_import));\\n\\n if c.debug {\\n println!(\"Targets: {:?}\", targets);\\n }\\n\\n chain!(\\n pass,\\n Polyfills {\\n mode: c.mode,\\n regenerator: should_enable!(Regenerator, true),\\n corejs: c.core_js.unwrap_or(Version {\\n major: 3,\\n minor: 0,\\n patch: 0\\n }),\\n shipped_proposals: c.shipped_proposals,\\n targets,\\n includes: included_modules,\\n excludes: excluded_modules,\\n }\\n )\\n}\\n\\n/// A map without allocation.\\n#[derive(Debug, Default, Deserialize, Clone, Copy, StaticMap)]\\n#[serde(deny_unknown_fields)]\\npub struct BrowserData {\\n #[serde(default)]\\n pub chrome: T,\\n #[serde(default)]\\n pub and_chr: T,\\n #[serde(default)]\\n pub and_ff: T,\\n #[serde(default)]\\n pub op_mob: T,\\n #[serde(default)]\\n pub ie: T,\\n #[serde(default)]\\n pub edge: T,\\n #[serde(default)]\\n pub firefox: T,\\n #[serde(default)]\\n pub safari: T,\\n #[serde(default)]\\n pub node: T,\\n #[serde(default)]\\n pub ios: T,\\n #[serde(default)]\\n pub samsung: T,\\n #[serde(default)]\\n pub opera: T,\\n #[serde(default)]\\n pub android: T,\\n #[serde(default)]\\n pub electron: T,\\n #[serde(default)]\\n pub phantom: T,\\n #[serde(default)]\\n pub opera_mobile: T,\\n #[serde(default)]\\n pub rhino: T,\\n}\\n\\n#[derive(Debug)]\\nstruct Polyfills {\\n mode: Option,\\n targets: Versions,\\n shipped_proposals: bool,\\n corejs: Version,\\n regenerator: bool,\\n includes: FxHashSet,\\n excludes: FxHashSet,\\n}\\n\\nimpl Fold for Polyfills {\\n fn fold_module(&mut self, mut m: Module) -> Module {\\n let span = m.span;\\n\\n let required = match self.mode {\\n None => Default::default(),\\n Some(Mode::Usage) => {\\n let mut r = match self.corejs {\\n Version { major: 2, .. } => {\\n let mut v = corejs2::UsageVisitor::new(self.targets);\\n m.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n\\n v.required\\n }\\n Version { major: 3, .. } => {\\n let mut v =\\n corejs3::UsageVisitor::new(self.targets, self.shipped_proposals);\\n m.visit_with(&Invalid { span: DUMMY_SP } as _, &mut v);\\n v.required\\n }\\n\\n _ => unimplemented!(\"corejs version other than 2 / 3\"),\\n };\\n\\n if regenerator::is_required(&m) {\\n r.insert(\"regenerator-runtime/runtime\".into());\\n }\\n\\n r\\n }\\n Some(Mode::Entry) => match self.corejs {\\n Version { major: 2, .. } => {\\n let mut v = corejs2::Entry::new(self.targets, self.regenerator);\\n m = m.fold_with(&mut v);\\n v.imports\\n }\\n\\n Version { major: 3, .. } => {\\n let mut v = corejs3::Entry::new(self.targets, self.corejs, !self.regenerator);\\n m = m.fold_with(&mut v);\\n v.imports\\n }\\n\\n _ => unimplemented!(\"corejs version other than 2 / 3\"),\\n },\\n };\\n let required = required\\n .into_iter()\\n .filter(|s| !self.excludes.contains(&**s))\\n .map(|s| -> JsWord {\\n if s != \"regenerator-runtime/runtime\" {\\n format!(\"core-js/modules/{}\", s).into()\\n } else {\\n format!(\"regenerator-runtime/runtime\").into()\\n }\\n })\\n .chain(self.includes.iter().map(|s| {\\n if s != \"regenerator-runtime/runtime\" {\\n format!(\"core-js/modules/{}\", s).into()\\n } else {\\n format!(\"regenerator-runtime/runtime\").into()\\n }\\n }))\\n .collect::>();\\n\\n if cfg!(debug_assertions) {\\n let mut v = required.into_iter().collect::>();\\n v.sort();\\n prepend_stmts(\\n &mut m.body,\\n v.into_iter().map(|src| {\\n ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {\\n span,\\n specifiers: vec![],\\n src: Str {\\n span: DUMMY_SP,\\n value: src,\\n has_escape: false,\\n kind: Default::default(),\\n },\\n type_only: false,\\n asserts: None,\\n }))\\n }),\\n );\\n } else {\\n prepend_stmts(\\n &mut m.body,\\n required.into_iter().map(|src| {\\n ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {\\n span,\\n specifiers: vec![],\\n src: Str {\\n span: DUMMY_SP,\\n value: src,\\n has_escape: false,\\n kind: Default::default(),\\n },\\n type_only: false,\\n asserts: None,\\n }))\\n }),\\n );\\n }\\n\\n m.body.retain(|item| match item {\\n ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {\\n src:\\n Str {\\n span: DUMMY_SP,\\n value: js_word!(\"\"),\\n ..\\n },\\n ..\\n })) => false,\\n _ => true,\\n });\\n\\n m\\n }\\n\\n fn fold_script(&mut self, _: Script) -> Script {\\n unimplemented!(\"automatic polyfill for scripts\")\\n }\\n}\\n\\n#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq)]\\npub enum Mode {\\n #[serde(rename = \"usage\")]\\n Usage,\\n #[serde(rename = \"entry\")]\\n Entry,\\n}\\n\\npub type Versions = BrowserData>;\\n\\nimpl BrowserData> {\\n pub fn is_any_target(&self) -> bool {\\n self.iter().all(|(_, v)| v.is_none())\\n }\\n\\n pub fn parse_versions<\\'a>(lines: impl Iterator) -> Result {\\n fn remap(key: &str) -> String {\\n match key {\\n \"and_chr\" => \"chrome\".into(),\\n \"and_ff\" => \"firefox\".into(),\\n \"ie_mob\" => \"ie\".into(),\\n \"ios_saf\" => \"ios\".into(),\\n \"op_mob\" => \"opera\".into(),\\n _ => key.into(),\\n }\\n }\\n\\n let browsers = lines.map(|v| {\\n let mut v = v.split(\\' \\');\\n (remap(v.next().unwrap()), v.next().unwrap().to_string())\\n });\\n\\n let mut data: Versions = BrowserData::default();\\n for (browser, version) in browsers {\\n match &*browser {\\n \"and_qq\" | \"and_uc\" | \"baidu\" | \"bb\" | \"kaios\" | \"op_mini\" => continue,\\n\\n _ => {}\\n }\\n\\n let version = if version.contains(\"-\") {\\n version.split(\\'-\\').next().unwrap().parse().unwrap()\\n } else {\\n version.parse().unwrap()\\n };\\n\\n // lowest version\\n if data[&browser].is_none() || data[&browser].unwrap() > version {\\n for (k, v) in data.iter_mut() {\\n if browser == k {\\n *v = Some(version);\\n }\\n }\\n }\\n }\\n\\n Ok(data)\\n }\\n}\\n\\n#[derive(Debug, Clone, Deserialize, Default)]\\n#[serde(rename_all = \"camelCase\")]\\npub struct Config {\\n #[serde(default)]\\n pub mode: Option,\\n\\n #[serde(default)]\\n pub debug: bool,\\n\\n #[serde(default)]\\n pub dynamic_import: bool,\\n\\n #[serde(default)]\\n pub loose: bool,\\n\\n /// Skipped es features.\\n ///\\n /// e.g.)\\n /// - `core-js/modules/foo`\\n #[serde(default)]\\n pub skip: Vec,\\n\\n #[serde(default)]\\n pub include: Vec,\\n\\n #[serde(default)]\\n pub exclude: Vec,\\n\\n /// The version of the used core js.\\n #[serde(default)]\\n pub core_js: Option,\\n\\n #[serde(default = \"default_targets\")]\\n pub targets: Option,\\n\\n #[serde(default = \"default_path\")]\\n pub path: PathBuf,\\n\\n #[serde(default)]\\n pub shipped_proposals: bool,\\n\\n #[serde(default)]\\n pub force_all_transforms: bool,\\n\\n #[serde(default)]\\n pub bugfixes: bool,\\n}\\n\\nfn default_targets() -> Option {\\n Some(Targets::Query(Query::Single(\"\".into())))\\n}\\n\\nfn default_path() -> PathBuf {\\n std::env::current_dir().unwrap()\\n}\\n\\n#[derive(Debug, Clone, Deserialize, FromVariant)]\\n#[serde(untagged)]\\npub enum FeatureOrModule {\\n Feature(Feature),\\n CoreJsModule(String),\\n}\\n\\nimpl FeatureOrModule {\\n pub fn split(vec: Vec) -> (Vec, FxHashSet) {\\n let mut features: Vec<_> = Default::default();\\n let mut modules: FxHashSet<_> = Default::default();\\n\\n for v in vec {\\n match v {\\n FeatureOrModule::Feature(f) => features.push(f),\\n FeatureOrModule::CoreJsModule(m) => {\\n modules.insert(m);\\n }\\n }\\n }\\n\\n (features, modules)\\n }\\n}\\n\\n#[derive(Debug, Clone, Deserialize, FromVariant)]\\n#[serde(untagged)]\\npub enum Targets {\\n Query(Query),\\n EsModules(EsModules),\\n Versions(Versions),\\n HashMap(FxHashMap),\\n}\\n\\n#[derive(Debug, Clone, Copy, Deserialize)]\\npub struct EsModules {\\n esmodules: bool,\\n}\\n\\n#[derive(Debug, Clone, Deserialize, FromVariant)]\\n#[serde(untagged)]\\npub enum QueryOrVersion {\\n Query(Query),\\n Version(Version),\\n}\\n\\n#[derive(Debug, Clone, Deserialize, FromVariant, Eq, PartialEq, PartialOrd, Ord, Hash)]\\n#[serde(untagged)]\\npub enum Query {\\n Single(String),\\n Multiple(Vec),\\n}\\n\\ntype QueryResult = Result;\\n\\nimpl Query {\\n fn exec(&self, path: &Path) -> QueryResult {\\n fn query(s: &[T], path: &Path) -> QueryResult\\n where\\n T: AsRef + Serialize,\\n {\\n let output = {\\n let output = Command::new(\"node\")\\n .current_dir(path)\\n .arg(\"-e\")\\n .arg(include_str!(\"query.js\"))\\n .arg(serde_json::to_string(&s).expect(\"failed to serialize with serde\"))\\n .output()\\n .expect(\"failed to collect output\");\\n if !output.status.success() {\\n println!(\"query.js: Status {:?}\", output.status,);\\n println!(\\n \"{}\\\\n{}\",\\n String::from_utf8_lossy(&output.stdout),\\n String::from_utf8_lossy(&output.stderr),\\n );\\n return Err(());\\n }\\n\\n output.stdout\\n };\\n\\n let browsers: Vec =\\n serde_json::from_slice(&output).expect(\"failed to read browser data output\");\\n let versions = BrowserData::parse_versions(browsers.iter().map(|s| &**s))\\n .expect(\"failed to parse browser version\");\\n\\n Ok(versions)\\n }\\n\\n static CACHE: Lazy> = Lazy::new(Default::default);\\n\\n if let Some(v) = CACHE.get(self) {\\n return match &*v {\\n Ok(v) => Ok(*v),\\n Err(err) => Err(*err),\\n };\\n }\\n\\n let result = match *self {\\n Query::Single(ref s) => query(&[s], path),\\n Query::Multiple(ref s) => query(&s, path),\\n };\\n\\n CACHE.insert(self.clone(), result);\\n\\n result\\n }\\n}\\n\\nfn targets_to_versions(v: Option, path: &Path) -> Result {\\n match v {\\n None => Ok(Default::default()),\\n Some(Targets::Versions(v)) => Ok(v),\\n Some(Targets::Query(q)) => q.exec(path),\\n Some(Targets::HashMap(mut map)) => {\\n let q = map.remove(\"browsers\").map(|q| match q {\\n QueryOrVersion::Query(q) => q.exec(path).expect(\"failed to run query\"),\\n _ => unreachable!(),\\n });\\n\\n let node = map.remove(\"node\").map(|q| match q {\\n QueryOrVersion::Version(v) => v,\\n QueryOrVersion::Query(..) => unreachable!(),\\n });\\n\\n if map.is_empty() {\\n if let Some(mut q) = q {\\n q.node = node;\\n return Ok(q);\\n }\\n }\\n\\n unimplemented!(\"Targets: {:?}\", map)\\n }\\n _ => unimplemented!(\"Option: {:?}\", v),\\n }\\n}\\n\\n#[cfg(test)]\\nmod tests {\\n use super::Query;\\n\\n #[test]\\n fn test_empty() {\\n let path = std::env::current_dir().unwrap();\\n let res = Query::Single(\"\".into()).exec(&path).unwrap();\\n assert!(\\n !res.is_any_target(),\\n \"empty query should return non-empty result\"\\n );\\n }\\n}\\n',\n", + " 'content_id': '069aad1a51101803144d9a956ce7f251f8e29668',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/ecmascript/preset-env/src/lib.rs',\n", + " 'size': 18585,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.37420610530628967,\n", + " 'avg_line_length': 33.74021352313167,\n", + " 'blob_id': '6112222a3f35a929a3cfd488fd32462b5245c82f',\n", + " 'content': 'use super::{\\n load::{Source, Specifier},\\n Bundler,\\n};\\nuse crate::{id::Id, load::Load, resolve::Resolve};\\nuse indexmap::IndexMap;\\nuse rustc_hash::FxHasher;\\nuse std::hash::BuildHasherDefault;\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{FileName, SyntaxContext};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::find_ids;\\nuse swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};\\n\\nimpl Bundler<\\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// TODO: Support pattern like\\n /// export const [a, b] = [1, 2]\\n pub(super) fn extract_export_info(\\n &self,\\n file_name: &FileName,\\n module: &mut Module,\\n export_ctxt: SyntaxContext,\\n ) -> RawExports {\\n self.run(|| {\\n let mut v = ExportFinder {\\n info: Default::default(),\\n file_name,\\n bundler: self,\\n export_ctxt,\\n };\\n\\n module.visit_mut_with(&mut v);\\n\\n v.info\\n })\\n }\\n}\\n\\n#[derive(Debug, Default)]\\npub(super) struct RawExports {\\n /// Key is None if it\\'s exported from the module itself.\\n pub items: IndexMap, Vec, BuildHasherDefault>,\\n}\\n\\n#[derive(Debug, Default)]\\npub(crate) struct Exports {\\n pub items: Vec,\\n pub reexports: Vec<(Source, Vec)>,\\n}\\n\\nstruct ExportFinder<\\'a, \\'b, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n info: RawExports,\\n file_name: &\\'a FileName,\\n bundler: &\\'a Bundler<\\'b, L, R>,\\n export_ctxt: SyntaxContext,\\n}\\n\\nimpl ExportFinder<\\'_, \\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n /// Returns `(local, export)`.\\n fn ctxt_for(&self, src: &JsWord) -> Option<(SyntaxContext, SyntaxContext)> {\\n // Don\\'t apply mark if it\\'s a core module.\\n if self\\n .bundler\\n .config\\n .external_modules\\n .iter()\\n .any(|v| v == src)\\n {\\n return None;\\n }\\n let path = self.bundler.resolve(self.file_name, src).ok()?;\\n let (_, local_mark, export_mark) = self.bundler.scope.module_id_gen.gen(&path);\\n\\n Some((\\n SyntaxContext::empty().apply_mark(local_mark),\\n SyntaxContext::empty().apply_mark(export_mark),\\n ))\\n }\\n\\n fn mark_as_wrapping_required(&self, src: &JsWord) {\\n // Don\\'t apply mark if it\\'s a core module.\\n if self\\n .bundler\\n .config\\n .external_modules\\n .iter()\\n .any(|v| v == src)\\n {\\n return;\\n }\\n let path = self.bundler.resolve(self.file_name, src);\\n let path = match path {\\n Ok(v) => v,\\n _ => return,\\n };\\n let (id, _, _) = self.bundler.scope.module_id_gen.gen(&path);\\n\\n self.bundler.scope.mark_as_wrapping_required(id);\\n }\\n}\\n\\nimpl VisitMut for ExportFinder<\\'_, \\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n noop_visit_mut_type!();\\n\\n fn visit_mut_module_item(&mut self, item: &mut ModuleItem) {\\n match item {\\n // TODO: Optimize pure constants\\n // ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {\\n // decl: Decl::Var(v),\\n // ..\\n // })) if v.kind == VarDeclKind::Const\\n // && v.decls.iter().all(|v| {\\n // (match v.name {\\n // Pat::Ident(..) => true,\\n // _ => false,\\n // }) && (match v.init {\\n // Some(box Expr::Lit(..)) => true,\\n // _ => false,\\n // })\\n // }) =>\\n // {\\n // self.info\\n // .pure_constants\\n // .extend(v.decls.into_iter().map(|decl| {\\n // let id = match decl.name {\\n // Pat::Ident(i) => i.into(),\\n // _ => unreachable!(),\\n // };\\n // let lit = match decl.init {\\n // Some(box Expr::Lit(l)) => l,\\n // _ => unreachable!(),\\n // };\\n // (id, lit)\\n // }));\\n // return ModuleItem::Stmt(Stmt::Empty(EmptyStmt { span: DUMMY_SP }));\\n // }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(decl)) => {\\n let v = self.info.items.entry(None).or_default();\\n v.push({\\n let i = match decl.decl {\\n Decl::Class(ref c) => &c.ident,\\n Decl::Fn(ref f) => &f.ident,\\n Decl::Var(ref var) => {\\n let ids: Vec = find_ids(&var.decls);\\n for id in ids {\\n v.push(Specifier::Specific {\\n local: id,\\n alias: None,\\n });\\n }\\n return;\\n }\\n _ => unreachable!(\"Decl in ExportDecl: {:?}\", decl.decl),\\n };\\n Specifier::Specific {\\n local: i.into(),\\n alias: None,\\n }\\n });\\n\\n return;\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(_decl)) => {\\n self.info\\n .items\\n .entry(None)\\n .or_default()\\n .push(Specifier::Specific {\\n local: Id::new(js_word!(\"default\"), SyntaxContext::empty()),\\n alias: None,\\n });\\n\\n return;\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(_expr)) => {\\n self.info\\n .items\\n .entry(None)\\n .or_default()\\n .push(Specifier::Specific {\\n local: Id::new(js_word!(\"default\"), SyntaxContext::empty()),\\n alias: None,\\n });\\n\\n return;\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(named)) => {\\n let ctxt = named\\n .src\\n .as_ref()\\n .map(|s| &s.value)\\n .and_then(|src| self.ctxt_for(src));\\n let mut need_wrapping = false;\\n\\n let v = self.info.items.entry(named.src.clone()).or_default();\\n for s in &mut named.specifiers {\\n match s {\\n ExportSpecifier::Namespace(n) => {\\n n.name.span.ctxt = self.export_ctxt;\\n\\n need_wrapping = true;\\n v.push(Specifier::Namespace {\\n local: n.name.clone().into(),\\n all: true,\\n })\\n }\\n ExportSpecifier::Default(d) => {\\n v.push(Specifier::Specific {\\n local: d.exported.clone().into(),\\n alias: Some(Id::new(js_word!(\"default\"), SyntaxContext::empty())),\\n });\\n }\\n ExportSpecifier::Named(n) => {\\n if let Some((_, export_ctxt)) = ctxt {\\n n.orig.span.ctxt = export_ctxt;\\n }\\n\\n match &mut n.exported {\\n Some(exported) => {\\n exported.span.ctxt = self.export_ctxt;\\n }\\n None => {\\n let mut exported: Ident = n.orig.clone();\\n exported.span.ctxt = self.export_ctxt;\\n n.exported = Some(exported);\\n }\\n }\\n\\n if let Some(exported) = &n.exported {\\n v.push(Specifier::Specific {\\n local: exported.clone().into(),\\n alias: Some(n.orig.clone().into()),\\n });\\n } else {\\n v.push(Specifier::Specific {\\n local: n.orig.clone().into(),\\n alias: None,\\n });\\n }\\n }\\n }\\n }\\n\\n if need_wrapping {\\n self.mark_as_wrapping_required(&named.src.as_ref().unwrap().value);\\n }\\n\\n return;\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportAll(all)) => {\\n let ctxt = self.ctxt_for(&all.src.value);\\n if let Some((_, export_ctxt)) = ctxt {\\n all.span.ctxt = export_ctxt;\\n }\\n\\n self.info.items.entry(Some(all.src.clone())).or_default();\\n }\\n _ => {}\\n }\\n }\\n}\\n',\n", + " 'content_id': 'f1c274a373edfe7b57ec27c1efcecb7f17c7e595',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/bundler/src/bundler/export.rs',\n", + " 'size': 9762,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3985311356187651,\n", + " 'avg_line_length': 33.5177539223782,\n", + " 'blob_id': 'e64090aba3111bdb0b19e844a6da374916673578',\n", + " 'content': 'use self::static_check::should_use_create_element;\\nuse crate::refresh::options::{deserialize_refresh, RefreshOptions};\\nuse dashmap::DashMap;\\nuse once_cell::sync::Lazy;\\nuse regex::Regex;\\nuse serde::{Deserialize, Serialize};\\nuse std::{iter, iter::once, mem};\\nuse string_enum::StringEnum;\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{\\n comments::{Comment, CommentKind, Comments},\\n iter::IdentifyLast,\\n sync::Lrc,\\n util::take::Take,\\n FileName, Mark, SourceMap, Span, Spanned, DUMMY_SP,\\n};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_parser::{Parser, StringInput, Syntax};\\nuse swc_ecma_transforms_base::helper;\\nuse swc_ecma_utils::{\\n drop_span, member_expr, prepend, private_ident, quote_ident, ExprFactory, HANDLER,\\n};\\nuse swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\n\\nmod static_check;\\n#[cfg(test)]\\nmod tests;\\n\\n/// https://babeljs.io/docs/en/babel-plugin-transform-react-jsx#runtime\\n#[derive(StringEnum, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]\\npub enum Runtime {\\n /// `automatic`\\n Automatic,\\n /// `classic`\\n Classic,\\n}\\n\\n/// Note: This will changed in v2\\nimpl Default for Runtime {\\n fn default() -> Self {\\n Runtime::Classic\\n }\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]\\n#[serde(rename_all = \"camelCase\")]\\n#[serde(deny_unknown_fields)]\\npub struct Options {\\n /// If this is `true`, swc will behave just like babel 8 with\\n /// `BABEL_8_BREAKING: true`.\\n #[serde(skip, default)]\\n pub next: bool,\\n\\n #[serde(default)]\\n pub runtime: Option,\\n\\n /// For automatic runtime\\n #[serde(default = \"default_import_source\")]\\n pub import_source: String,\\n\\n #[serde(default = \"default_pragma\")]\\n pub pragma: String,\\n #[serde(default = \"default_pragma_frag\")]\\n pub pragma_frag: String,\\n\\n #[serde(default = \"default_throw_if_namespace\")]\\n pub throw_if_namespace: bool,\\n\\n #[serde(default)]\\n pub development: bool,\\n\\n /// TODO: Remove this field.\\n #[serde(default, alias = \"useBuiltIns\")]\\n pub use_builtins: bool,\\n\\n #[serde(default)]\\n pub use_spread: bool,\\n\\n #[serde(default, deserialize_with = \"deserialize_refresh\")]\\n // default to disabled since this is still considered as experimental by now\\n pub refresh: Option,\\n}\\n\\nimpl Default for Options {\\n fn default() -> Self {\\n Options {\\n next: false,\\n runtime: Default::default(),\\n import_source: default_import_source(),\\n pragma: default_pragma(),\\n pragma_frag: default_pragma_frag(),\\n throw_if_namespace: default_throw_if_namespace(),\\n development: false,\\n use_builtins: false,\\n use_spread: false,\\n // since this is considered experimental, we disable it by default\\n refresh: None,\\n }\\n }\\n}\\n\\nfn default_import_source() -> String {\\n \"react\".into()\\n}\\n\\nfn default_pragma() -> String {\\n \"React.createElement\".into()\\n}\\n\\nfn default_pragma_frag() -> String {\\n \"React.Fragment\".into()\\n}\\n\\nfn default_throw_if_namespace() -> bool {\\n true\\n}\\n\\nfn parse_classic_option(\\n cm: &SourceMap,\\n name: &str,\\n src: String,\\n top_level_mark: Mark,\\n) -> Box {\\n static CACHE: Lazy>> =\\n Lazy::new(|| DashMap::with_capacity(2));\\n\\n let fm = cm.new_source_file(FileName::Custom(format!(\"\", name)), src);\\n if let Some(expr) = CACHE.get(&((*fm.src).clone(), top_level_mark)) {\\n return expr.clone();\\n }\\n\\n let mut expr = Parser::new(Syntax::default(), StringInput::from(&*fm), None)\\n .parse_expr()\\n .map_err(|e| {\\n if HANDLER.is_set() {\\n HANDLER.with(|h| e.into_diagnostic(h).emit())\\n }\\n })\\n .map(drop_span)\\n .unwrap_or_else(|()| {\\n panic!(\\n \"failed to parse jsx option {}: \\'{}\\' is not an expression\",\\n name, fm.src,\\n )\\n });\\n\\n apply_mark(&mut expr, top_level_mark);\\n CACHE.insert(((*fm.src).clone(), top_level_mark), expr.clone());\\n\\n expr\\n}\\n\\nfn apply_mark(e: &mut Expr, mark: Mark) {\\n match e {\\n Expr::Ident(i) => {\\n i.span = i.span.apply_mark(mark);\\n }\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n ..\\n }) => {\\n apply_mark(&mut **obj, mark);\\n }\\n _ => {}\\n }\\n}\\n\\n/// `@babel/plugin-transform-react-jsx`\\n///\\n/// Turn JSX into React function calls\\n///\\n///\\n/// `top_level_mark` should be [Mark] passed to\\n/// [swc_ecma_transforms_base::resolver::resolver_with_mark].\\npub fn jsx(\\n cm: Lrc,\\n comments: Option,\\n options: Options,\\n top_level_mark: Mark,\\n) -> impl Fold + VisitMut\\nwhere\\n C: Comments,\\n{\\n as_folder(Jsx {\\n cm: cm.clone(),\\n top_level_mark,\\n next: options.next,\\n runtime: options.runtime.unwrap_or_default(),\\n import_source: options.import_source.into(),\\n import_jsx: None,\\n import_jsxs: None,\\n import_fragment: None,\\n import_create_element: None,\\n\\n pragma: ExprOrSuper::Expr(parse_classic_option(\\n &cm,\\n \"pragma\",\\n options.pragma,\\n top_level_mark,\\n )),\\n comments,\\n pragma_frag: ExprOrSpread {\\n spread: None,\\n expr: parse_classic_option(&cm, \"pragmaFrag\", options.pragma_frag, top_level_mark),\\n },\\n use_builtins: options.use_builtins,\\n use_spread: options.use_spread,\\n throw_if_namespace: options.throw_if_namespace,\\n top_level_node: true,\\n })\\n}\\n\\nstruct Jsx\\nwhere\\n C: Comments,\\n{\\n cm: Lrc,\\n\\n top_level_mark: Mark,\\n\\n next: bool,\\n runtime: Runtime,\\n /// For automatic runtime.\\n import_source: JsWord,\\n /// For automatic runtime.\\n import_jsx: Option,\\n /// For automatic runtime.\\n import_jsxs: Option,\\n /// For automatic runtime.\\n import_create_element: Option,\\n /// For automatic runtime.\\n import_fragment: Option,\\n top_level_node: bool,\\n\\n pragma: ExprOrSuper,\\n comments: Option,\\n pragma_frag: ExprOrSpread,\\n use_builtins: bool,\\n use_spread: bool,\\n throw_if_namespace: bool,\\n}\\n\\nimpl Jsx\\nwhere\\n C: Comments,\\n{\\n fn jsx_frag_to_expr(&mut self, el: JSXFragment) -> Expr {\\n let span = el.span();\\n\\n let use_jsxs = count_children(&el.children) > 1;\\n\\n if let Some(comments) = &self.comments {\\n comments.add_pure_comment(span.lo);\\n }\\n\\n match self.runtime {\\n Runtime::Automatic => {\\n let jsx = if use_jsxs {\\n self.import_jsxs\\n .get_or_insert_with(|| private_ident!(\"_jsxs\"))\\n .clone()\\n } else {\\n self.import_jsx\\n .get_or_insert_with(|| private_ident!(\"_jsx\"))\\n .clone()\\n };\\n\\n let fragment = self\\n .import_fragment\\n .get_or_insert_with(|| private_ident!(\"_Fragment\"))\\n .clone();\\n\\n let mut props_obj = ObjectLit {\\n span: DUMMY_SP,\\n props: vec![],\\n };\\n\\n let children = el\\n .children\\n .into_iter()\\n .filter_map(|child| self.jsx_elem_child_to_expr(child))\\n .map(Some)\\n .collect::>();\\n\\n match children.len() {\\n 0 => {}\\n 1 if children[0].as_ref().unwrap().spread.is_none() => {\\n props_obj\\n .props\\n .push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\"children\")),\\n value: children.into_iter().next().flatten().unwrap().expr,\\n }))));\\n }\\n _ => {\\n props_obj\\n .props\\n .push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\"children\")),\\n value: Box::new(Expr::Array(ArrayLit {\\n span: DUMMY_SP,\\n elems: children,\\n })),\\n }))));\\n }\\n }\\n\\n Expr::Call(CallExpr {\\n span,\\n callee: jsx.as_callee(),\\n args: vec![fragment.as_arg(), props_obj.as_arg()],\\n type_args: None,\\n })\\n }\\n Runtime::Classic => {\\n Expr::Call(CallExpr {\\n span,\\n callee: self.pragma.clone(),\\n args: iter::once(self.pragma_frag.clone())\\n // attribute: null\\n .chain(iter::once(Lit::Null(Null { span: DUMMY_SP }).as_arg()))\\n .chain({\\n // Children\\n el.children\\n .into_iter()\\n .filter_map(|c| self.jsx_elem_child_to_expr(c))\\n })\\n .collect(),\\n type_args: None,\\n })\\n }\\n }\\n }\\n\\n /// # Automatic\\n ///\\n ///\\n ///\\n /// # Classic\\n ///\\n ///
=> React.createElement(\\'div\\', null);\\n fn jsx_elem_to_expr(&mut self, el: JSXElement) -> Expr {\\n let top_level_node = self.top_level_node;\\n let span = el.span();\\n let use_create_element = should_use_create_element(&el.opening.attrs);\\n self.top_level_node = false;\\n\\n let name = self.jsx_name(el.opening.name);\\n\\n if let Some(comments) = &self.comments {\\n comments.add_pure_comment(span.lo);\\n }\\n\\n match self.runtime {\\n Runtime::Automatic => {\\n // function jsx(tagName: string, props: { children: Node[], ... }, key: string)\\n\\n let use_jsxs = count_children(&el.children) > 1;\\n\\n let jsx = if use_create_element {\\n self.import_create_element\\n .get_or_insert_with(|| private_ident!(\"_createElement\"))\\n .clone()\\n } else if use_jsxs {\\n self.import_jsxs\\n .get_or_insert_with(|| private_ident!(\"_jsxs\"))\\n .clone()\\n } else {\\n self.import_jsx\\n .get_or_insert_with(|| private_ident!(\"_jsx\"))\\n .clone()\\n };\\n\\n let mut props_obj = ObjectLit {\\n span: DUMMY_SP,\\n props: vec![],\\n };\\n\\n let mut key = None;\\n\\n for attr in el.opening.attrs {\\n match attr {\\n JSXAttrOrSpread::JSXAttr(attr) => {\\n //\\n match attr.name {\\n JSXAttrName::Ident(i) => {\\n //\\n if !use_create_element && i.sym == js_word!(\"key\") {\\n key = attr\\n .value\\n .map(jsx_attr_value_to_expr)\\n .flatten()\\n .map(|expr| ExprOrSpread { expr, spread: None });\\n assert_ne!(\\n key, None,\\n \"value of property \\'key\\' should not be empty\"\\n );\\n continue;\\n }\\n\\n let value = match attr.value {\\n Some(v) => jsx_attr_value_to_expr(v)\\n .expect(\"empty expression container?\"),\\n None => Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n };\\n\\n // TODO: Check if `i` is a valid identifier.\\n let key = if i.sym.contains(\"-\") {\\n PropName::Str(Str {\\n span: i.span,\\n value: i.sym,\\n has_escape: false,\\n kind: StrKind::Normal {\\n contains_quote: false,\\n },\\n })\\n } else {\\n PropName::Ident(i)\\n };\\n props_obj.props.push(PropOrSpread::Prop(Box::new(\\n Prop::KeyValue(KeyValueProp { key, value }),\\n )));\\n }\\n JSXAttrName::JSXNamespacedName(JSXNamespacedName { ns, name }) => {\\n if self.throw_if_namespace {\\n HANDLER.with(|handler| {\\n handler\\n .struct_span_err(\\n span,\\n \"JSX Namespace is disabled by default because \\\\\\n react does not support it yet. You can \\\\\\n specify jsc.transform.react.throwIfNamespace \\\\\\n to false to override default behavior\",\\n )\\n .emit()\\n });\\n }\\n\\n let value = match attr.value {\\n Some(v) => jsx_attr_value_to_expr(v)\\n .expect(\"empty expression container?\"),\\n None => Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: DUMMY_SP,\\n value: true,\\n }))),\\n };\\n\\n let key = Str {\\n span,\\n value: format!(\"{}:{}\", ns.sym, name.sym).into(),\\n has_escape: false,\\n kind: Default::default(),\\n };\\n let key = PropName::Str(key);\\n\\n props_obj.props.push(PropOrSpread::Prop(Box::new(\\n Prop::KeyValue(KeyValueProp { key, value }),\\n )));\\n }\\n }\\n }\\n JSXAttrOrSpread::SpreadElement(attr) => match *attr.expr {\\n Expr::Object(obj) => {\\n props_obj.props.extend(obj.props);\\n }\\n _ => {\\n props_obj.props.push(PropOrSpread::Spread(attr));\\n }\\n },\\n }\\n }\\n\\n let children = el\\n .children\\n .into_iter()\\n .filter_map(|child| self.jsx_elem_child_to_expr(child))\\n .map(Some)\\n .collect::>();\\n\\n match children.len() {\\n 0 => {}\\n 1 if children[0].as_ref().unwrap().spread.is_none() => {\\n props_obj\\n .props\\n .push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\"children\")),\\n value: children.into_iter().next().flatten().unwrap().expr,\\n }))));\\n }\\n _ => {\\n props_obj\\n .props\\n .push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {\\n key: PropName::Ident(quote_ident!(\"children\")),\\n value: Box::new(Expr::Array(ArrayLit {\\n span: DUMMY_SP,\\n elems: children,\\n })),\\n }))));\\n }\\n }\\n\\n self.top_level_node = top_level_node;\\n\\n Expr::Call(CallExpr {\\n span,\\n callee: jsx.as_callee(),\\n args: once(name.as_arg())\\n .chain(once(props_obj.as_arg()))\\n .chain(key)\\n .collect(),\\n type_args: Default::default(),\\n })\\n }\\n Runtime::Classic => {\\n Expr::Call(CallExpr {\\n span,\\n callee: self.pragma.clone(),\\n args: iter::once(name.as_arg())\\n .chain(iter::once({\\n // Attributes\\n self.fold_attrs_for_classic(el.opening.attrs).as_arg()\\n }))\\n .chain({\\n // Children\\n el.children\\n .into_iter()\\n .filter_map(|c| self.jsx_elem_child_to_expr(c))\\n })\\n .collect(),\\n type_args: Default::default(),\\n })\\n }\\n }\\n }\\n\\n fn jsx_elem_child_to_expr(&mut self, c: JSXElementChild) -> Option {\\n self.top_level_node = false;\\n\\n Some(match c {\\n JSXElementChild::JSXText(text) => {\\n // TODO(kdy1): Optimize\\n let s = Str {\\n span: text.span,\\n has_escape: text.raw != text.value,\\n value: jsx_text_to_str(text.value),\\n kind: Default::default(),\\n };\\n if s.value.is_empty() {\\n return None;\\n }\\n\\n Lit::Str(s).as_arg()\\n }\\n JSXElementChild::JSXExprContainer(JSXExprContainer {\\n expr: JSXExpr::Expr(e),\\n ..\\n }) => e.as_arg(),\\n JSXElementChild::JSXExprContainer(JSXExprContainer {\\n expr: JSXExpr::JSXEmptyExpr(..),\\n ..\\n }) => return None,\\n JSXElementChild::JSXElement(el) => self.jsx_elem_to_expr(*el).as_arg(),\\n JSXElementChild::JSXFragment(el) => self.jsx_frag_to_expr(el).as_arg(),\\n JSXElementChild::JSXSpreadChild(JSXSpreadChild { span, .. }) => {\\n HANDLER.with(|handler| {\\n handler\\n .struct_span_err(span, \"Spread children are not supported in React.\")\\n .emit();\\n });\\n return None;\\n }\\n })\\n }\\n\\n fn fold_attrs_for_classic(&mut self, attrs: Vec) -> Box {\\n if self.next {\\n self.fold_attrs_for_next_classic(attrs)\\n } else {\\n self.fold_attrs_for_old_classic(attrs)\\n }\\n }\\n\\n /// Runtiem; `classic`\\n fn fold_attrs_for_next_classic(&mut self, attrs: Vec) -> Box {\\n if attrs.is_empty() {\\n return Box::new(Expr::Lit(Lit::Null(Null { span: DUMMY_SP })));\\n }\\n let attr_cnt = attrs.len();\\n\\n let mut props = vec![];\\n for attr in attrs {\\n match attr {\\n JSXAttrOrSpread::JSXAttr(attr) => {\\n props.push(PropOrSpread::Prop(Box::new(self.attr_to_prop(attr))))\\n }\\n JSXAttrOrSpread::SpreadElement(spread) => {\\n if attr_cnt == 1 {\\n return spread.expr;\\n }\\n // babel does some optimizations\\n match *spread.expr {\\n Expr::Object(obj) => props.extend(obj.props),\\n _ => props.push(PropOrSpread::Spread(spread)),\\n }\\n }\\n }\\n }\\n\\n let obj = ObjectLit {\\n span: DUMMY_SP,\\n props,\\n };\\n\\n Box::new(Expr::Object(obj))\\n }\\n\\n /// Runtime: `automatic`\\n fn fold_attrs_for_old_classic(&mut self, attrs: Vec) -> Box {\\n if attrs.is_empty() {\\n return Box::new(Expr::Lit(Lit::Null(Null { span: DUMMY_SP })));\\n }\\n\\n if self.use_spread {\\n return self.fold_attrs_for_next_classic(attrs);\\n }\\n\\n let is_complex = attrs.iter().any(|a| match *a {\\n JSXAttrOrSpread::SpreadElement(..) => true,\\n _ => false,\\n });\\n\\n if is_complex {\\n let mut args = vec![];\\n let mut cur_obj_props = vec![];\\n macro_rules! check {\\n () => {{\\n if args.is_empty() || !cur_obj_props.is_empty() {\\n args.push(\\n ObjectLit {\\n span: DUMMY_SP,\\n props: mem::replace(&mut cur_obj_props, vec![]),\\n }\\n .as_arg(),\\n )\\n }\\n }};\\n }\\n for attr in attrs {\\n match attr {\\n JSXAttrOrSpread::JSXAttr(a) => {\\n cur_obj_props.push(PropOrSpread::Prop(Box::new(self.attr_to_prop(a))))\\n }\\n JSXAttrOrSpread::SpreadElement(e) => {\\n check!();\\n args.push(e.expr.as_arg());\\n }\\n }\\n }\\n check!();\\n\\n // calls `_extends` or `Object.assign`\\n Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: {\\n if self.use_builtins {\\n member_expr!(DUMMY_SP, Object.assign).as_callee()\\n } else {\\n helper!(extends, \"extends\")\\n }\\n },\\n args,\\n type_args: None,\\n }))\\n } else {\\n Box::new(Expr::Object(ObjectLit {\\n span: DUMMY_SP,\\n props: attrs\\n .into_iter()\\n .map(|a| match a {\\n JSXAttrOrSpread::JSXAttr(a) => a,\\n _ => unreachable!(),\\n })\\n .map(|attr| {\\n let mut v = self.attr_to_prop(attr);\\n v.visit_mut_with(self);\\n v\\n })\\n .map(Box::new)\\n .map(PropOrSpread::Prop)\\n .collect(),\\n }))\\n }\\n }\\n\\n fn attr_to_prop(&mut self, a: JSXAttr) -> Prop {\\n let key = to_prop_name(a.name);\\n let value = a\\n .value\\n .map(|v| match v {\\n JSXAttrValue::Lit(Lit::Str(s)) => Box::new(Expr::Lit(Lit::Str(Str {\\n span: s.span,\\n value: transform_jsx_attr_str(&s.value).into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n JSXAttrValue::JSXExprContainer(JSXExprContainer {\\n expr: JSXExpr::Expr(e),\\n ..\\n }) => e,\\n JSXAttrValue::JSXElement(element) => Box::new(self.jsx_elem_to_expr(*element)),\\n JSXAttrValue::JSXFragment(fragment) => Box::new(self.jsx_frag_to_expr(fragment)),\\n JSXAttrValue::Lit(lit) => Box::new(lit.into()),\\n JSXAttrValue::JSXExprContainer(JSXExprContainer {\\n span: _,\\n expr: JSXExpr::JSXEmptyExpr(_),\\n }) => unreachable!(\"attr_to_prop(JSXEmptyExpr)\"),\\n })\\n .unwrap_or_else(|| {\\n Box::new(Expr::Lit(Lit::Bool(Bool {\\n span: key.span(),\\n value: true,\\n })))\\n });\\n Prop::KeyValue(KeyValueProp { key, value })\\n }\\n}\\n\\nimpl Jsx\\nwhere\\n C: Comments,\\n{\\n fn parse_directives(&mut self, span: Span) -> bool {\\n let mut found = false;\\n\\n let leading = if let Some(comments) = &self.comments {\\n let leading = comments.take_leading(span.lo);\\n\\n if let Some(leading) = &leading {\\n found |= self.parse_comment_contents(span, &leading);\\n }\\n\\n leading\\n } else {\\n None\\n };\\n\\n if let Some(leading) = leading {\\n if let Some(comments) = &self.comments {\\n comments.add_leading_comments(span.lo, leading);\\n }\\n }\\n\\n found\\n }\\n\\n /// If we found required jsx directives, we returns true.\\n fn parse_comment_contents(&mut self, span: Span, leading: &[Comment]) -> bool {\\n let mut found = false;\\n\\n for cmt in leading {\\n if cmt.kind != CommentKind::Block {\\n continue;\\n }\\n\\n for line in cmt.text.lines() {\\n let mut line = line.trim();\\n if line.starts_with(\\'*\\') {\\n line = line[1..].trim();\\n }\\n\\n if !line.starts_with(\"@jsx\") {\\n continue;\\n }\\n\\n if line.starts_with(\"@jsxRuntime \") {\\n let src = line.replace(\"@jsxRuntime \", \"\").trim().to_string();\\n found = true;\\n if src == \"classic\" {\\n self.runtime = Runtime::Classic;\\n } else if src == \"automatic\" {\\n self.runtime = Runtime::Automatic;\\n } else {\\n todo!(\"proper error reporting for wrong `@jsxRuntime`\")\\n }\\n continue;\\n }\\n\\n if line.starts_with(\"@jsxImportSource\") {\\n let src = line.replace(\"@jsxImportSource\", \"\").trim().to_string();\\n self.runtime = Runtime::Automatic;\\n self.import_source = src.into();\\n found = true;\\n }\\n\\n if line.starts_with(\"@jsxFrag\") {\\n found = true;\\n\\n if self.runtime == Runtime::Automatic {\\n HANDLER.with(|handler| {\\n handler\\n .struct_span_err(\\n span,\\n \"pragma and pragmaFrag cannot be set when runtime is automatic\",\\n )\\n .emit()\\n });\\n }\\n\\n let src = line.replace(\"@jsxFrag\", \"\").trim().to_string();\\n self.pragma_frag = ExprOrSpread {\\n expr: parse_classic_option(\\n &self.cm,\\n \"module-jsx-pragma-frag\",\\n src,\\n self.top_level_mark,\\n ),\\n spread: None,\\n };\\n } else if line.starts_with(\"@jsx \") {\\n found = true;\\n\\n if self.runtime == Runtime::Automatic {\\n HANDLER.with(|handler| {\\n handler\\n .struct_span_err(\\n span,\\n \"pragma and pragmaFrag cannot be set when runtime is automatic\",\\n )\\n .emit()\\n });\\n }\\n\\n let src = line.replace(\"@jsx\", \"\").trim().to_string();\\n\\n self.pragma = ExprOrSuper::Expr(parse_classic_option(\\n &self.cm,\\n \"module-jsx-pragma\",\\n src,\\n self.top_level_mark,\\n ));\\n }\\n }\\n }\\n\\n found\\n }\\n}\\n\\nimpl VisitMut for Jsx\\nwhere\\n C: Comments,\\n{\\n noop_visit_mut_type!();\\n\\n fn visit_mut_expr(&mut self, expr: &mut Expr) {\\n let top_level_node = self.top_level_node;\\n let mut did_work = false;\\n\\n if let Expr::JSXElement(el) = expr {\\n did_work = true;\\n //
=> React.createElement(\\'div\\', null);\\n *expr = self.jsx_elem_to_expr(*el.take());\\n } else if let Expr::JSXFragment(frag) = expr {\\n // <> => React.createElement(React.Fragment, null);\\n did_work = true;\\n *expr = self.jsx_frag_to_expr(frag.take());\\n } else if let Expr::Paren(ParenExpr {\\n expr: inner_expr, ..\\n }) = expr\\n {\\n if let Expr::JSXElement(el) = &mut **inner_expr {\\n did_work = true;\\n *expr = self.jsx_elem_to_expr(*el.take());\\n } else if let Expr::JSXFragment(frag) = &mut **inner_expr {\\n // <> => React.createElement(React.Fragment, null);\\n did_work = true;\\n *expr = self.jsx_frag_to_expr(frag.take());\\n }\\n }\\n\\n if did_work {\\n self.top_level_node = false;\\n }\\n\\n expr.visit_mut_children_with(self);\\n\\n self.top_level_node = top_level_node;\\n }\\n\\n fn visit_mut_member_expr(&mut self, e: &mut MemberExpr) {\\n e.obj.visit_mut_with(self);\\n if e.computed {\\n e.prop.visit_mut_with(self);\\n }\\n }\\n\\n fn visit_mut_module(&mut self, module: &mut Module) {\\n self.parse_directives(module.span);\\n\\n for item in &module.body {\\n let span = item.span();\\n if self.parse_directives(span) {\\n break;\\n }\\n }\\n\\n module.visit_mut_children_with(self);\\n\\n if self.runtime == Runtime::Automatic {\\n if let Some(local) = self.import_create_element.take() {\\n let specifier = ImportSpecifier::Named(ImportNamedSpecifier {\\n span: DUMMY_SP,\\n local,\\n imported: Some(Ident::new(\"createElement\".into(), DUMMY_SP)),\\n is_type_only: false,\\n });\\n prepend(\\n &mut module.body,\\n ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {\\n span: DUMMY_SP,\\n specifiers: vec![specifier],\\n src: Str {\\n span: DUMMY_SP,\\n value: \"react\".into(),\\n has_escape: false,\\n kind: Default::default(),\\n },\\n type_only: Default::default(),\\n asserts: Default::default(),\\n })),\\n );\\n }\\n\\n let imports = self\\n .import_jsx\\n .take()\\n .map(|local| ImportNamedSpecifier {\\n span: DUMMY_SP,\\n local,\\n imported: Some(quote_ident!(\"jsx\")),\\n is_type_only: false,\\n })\\n .into_iter()\\n .chain(self.import_jsxs.take().map(|local| ImportNamedSpecifier {\\n span: DUMMY_SP,\\n local,\\n imported: Some(quote_ident!(\"jsxs\")),\\n is_type_only: false,\\n }))\\n .chain(\\n self.import_fragment\\n .take()\\n .map(|local| ImportNamedSpecifier {\\n span: DUMMY_SP,\\n local,\\n imported: Some(quote_ident!(\"Fragment\")),\\n is_type_only: false,\\n }),\\n )\\n .map(ImportSpecifier::Named)\\n .collect::>();\\n\\n if !imports.is_empty() {\\n prepend(\\n &mut module.body,\\n ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {\\n span: DUMMY_SP,\\n specifiers: imports,\\n src: Str {\\n span: DUMMY_SP,\\n value: format!(\"{}/jsx-runtime\", self.import_source).into(),\\n has_escape: false,\\n kind: Default::default(),\\n },\\n type_only: Default::default(),\\n asserts: Default::default(),\\n })),\\n );\\n }\\n }\\n }\\n}\\n\\nimpl Jsx\\nwhere\\n C: Comments,\\n{\\n fn jsx_name(&self, name: JSXElementName) -> Box {\\n let span = name.span();\\n match name {\\n JSXElementName::Ident(i) => {\\n if i.sym == js_word!(\"this\") {\\n return Box::new(Expr::This(ThisExpr { span }));\\n }\\n\\n // If it starts with lowercase\\n if i.as_ref().starts_with(|c: char| c.is_ascii_lowercase()) {\\n Box::new(Expr::Lit(Lit::Str(Str {\\n span,\\n value: i.sym,\\n has_escape: false,\\n kind: StrKind::Normal {\\n contains_quote: false,\\n },\\n })))\\n } else {\\n Box::new(Expr::Ident(i))\\n }\\n }\\n JSXElementName::JSXNamespacedName(JSXNamespacedName { ref ns, ref name }) => {\\n if self.throw_if_namespace {\\n HANDLER.with(|handler| {\\n handler\\n .struct_span_err(\\n span,\\n \"JSX Namespace is disabled by default because react does not \\\\\\n support it yet. You can specify \\\\\\n jsc.transform.react.throwIfNamespace to false to override \\\\\\n default behavior\",\\n )\\n .emit()\\n });\\n }\\n Box::new(Expr::Lit(Lit::Str(Str {\\n span,\\n value: format!(\"{}:{}\", ns.sym, name.sym).into(),\\n has_escape: false,\\n kind: Default::default(),\\n })))\\n }\\n JSXElementName::JSXMemberExpr(JSXMemberExpr { obj, prop }) => {\\n fn convert_obj(obj: JSXObject) -> ExprOrSuper {\\n let span = obj.span();\\n\\n match obj {\\n JSXObject::Ident(i) => {\\n if i.sym == js_word!(\"this\") {\\n return ExprOrSuper::Expr(Box::new(Expr::This(ThisExpr { span })));\\n }\\n i.as_obj()\\n }\\n JSXObject::JSXMemberExpr(e) => {\\n let e = *e;\\n MemberExpr {\\n span,\\n obj: convert_obj(e.obj),\\n prop: Box::new(Expr::Ident(e.prop)),\\n computed: false,\\n }\\n .as_obj()\\n }\\n }\\n }\\n Box::new(Expr::Member(MemberExpr {\\n span,\\n obj: convert_obj(obj),\\n prop: Box::new(Expr::Ident(prop)),\\n computed: false,\\n }))\\n }\\n }\\n }\\n}\\n\\nfn to_prop_name(n: JSXAttrName) -> PropName {\\n let span = n.span();\\n\\n match n {\\n JSXAttrName::Ident(i) => {\\n if i.sym.contains(\\'-\\') {\\n PropName::Str(Str {\\n span,\\n value: i.sym,\\n has_escape: false,\\n kind: StrKind::Normal {\\n contains_quote: false,\\n },\\n })\\n } else {\\n PropName::Ident(i)\\n }\\n }\\n JSXAttrName::JSXNamespacedName(JSXNamespacedName { ns, name }) => PropName::Str(Str {\\n span,\\n value: format!(\"{}:{}\", ns.sym, name.sym).into(),\\n has_escape: false,\\n kind: Default::default(),\\n }),\\n }\\n}\\n\\n#[inline]\\nfn jsx_text_to_str(t: JsWord) -> JsWord {\\n static SPACE_NL_START: Lazy =\\n Lazy::new(|| Regex::new(\"^[\\\\t\\'\\\\n\\\\x0C\\\\r ]*\\\\n[\\\\t\\'\\\\n\\\\x0C\\\\r ]*\").unwrap());\\n static SPACE_NL_END: Lazy =\\n Lazy::new(|| Regex::new(\"[\\\\t\\'\\\\n\\\\x0C\\\\r ]*\\\\n[\\\\t\\'\\\\n\\\\x0C\\\\r ]*$\").unwrap());\\n\\n if t == *\" \" {\\n return t;\\n }\\n\\n if !t.contains(\\' \\') && !t.contains(\\'\\\\n\\') {\\n return t;\\n }\\n\\n let s = SPACE_NL_START.replace_all(&t, \"\");\\n let s = SPACE_NL_END.replace_all(&s, \"\");\\n let need_leading_space = s.starts_with(\\' \\');\\n let need_trailing_space = s.ends_with(\\' \\');\\n\\n let mut buf = String::from(if need_leading_space { \" \" } else { \"\" });\\n\\n for (last, s) in s\\n .split(|c: char| c != \\'\\\\u{a0}\\' && c.is_ascii_whitespace())\\n .filter(|s| !s.is_empty())\\n .identify_last()\\n {\\n buf.push_str(s);\\n if !last {\\n buf.push(\\' \\');\\n }\\n }\\n\\n if need_trailing_space && !buf.ends_with(\\' \\') {\\n buf.push(\\' \\');\\n }\\n\\n buf.into()\\n}\\n\\nfn jsx_attr_value_to_expr(v: JSXAttrValue) -> Option> {\\n Some(match v {\\n JSXAttrValue::Lit(Lit::Str(s)) => Box::new(Expr::Lit(Lit::Str(Str {\\n span: s.span,\\n value: transform_jsx_attr_str(&s.value).into(),\\n has_escape: false,\\n kind: Default::default(),\\n }))),\\n JSXAttrValue::Lit(lit) => Box::new(lit.into()),\\n JSXAttrValue::JSXExprContainer(e) => match e.expr {\\n JSXExpr::JSXEmptyExpr(_) => None?,\\n JSXExpr::Expr(e) => e,\\n },\\n JSXAttrValue::JSXElement(e) => Box::new(Expr::JSXElement(e)),\\n JSXAttrValue::JSXFragment(f) => Box::new(Expr::JSXFragment(f)),\\n })\\n}\\n\\nfn count_children(children: &[JSXElementChild]) -> usize {\\n children\\n .iter()\\n .filter(|v| match v {\\n JSXElementChild::JSXText(text) => {\\n let text = jsx_text_to_str(text.value.clone());\\n !text.is_empty()\\n }\\n JSXElementChild::JSXExprContainer(e) => match e.expr {\\n JSXExpr::JSXEmptyExpr(_) => false,\\n JSXExpr::Expr(_) => true,\\n },\\n JSXElementChild::JSXSpreadChild(_) => true,\\n JSXElementChild::JSXElement(_) => true,\\n JSXElementChild::JSXFragment(_) => true,\\n })\\n .count()\\n}\\n\\nfn transform_jsx_attr_str(v: &str) -> String {\\n let single_quote = false;\\n let mut buf = String::with_capacity(v.len());\\n\\n for c in v.chars() {\\n match c {\\n \\'\\\\u{0008}\\' => buf.push_str(\"\\\\\\\\b\"),\\n \\'\\\\u{000c}\\' => buf.push_str(\"\\\\\\\\f\"),\\n \\'\\\\n\\' => buf.push_str(\"\\\\\\\\n\"),\\n \\'\\\\r\\' => buf.push_str(\"\\\\\\\\r\"),\\n \\'\\\\t\\' => buf.push_str(\"\\\\\\\\t\"),\\n \\'\\\\u{000b}\\' => buf.push_str(\"\\\\\\\\v\"),\\n \\'\\\\0\\' => buf.push_str(\"\\\\\\\\x00\"),\\n\\n \\'\\\\\\\\\\' => buf.push_str(\"\\\\\\\\\\\\\\\\\"),\\n\\n \\'\\\\\\'\\' if single_quote => buf.push_str(\"\\\\\\\\\\'\"),\\n \\'\"\\' if !single_quote => buf.push_str(\"\\\\\\\\\\\\\"\"),\\n\\n \\'\\\\x01\\'..=\\'\\\\x0f\\' | \\'\\\\x10\\'..=\\'\\\\x1f\\' => {\\n buf.push(c);\\n }\\n\\n \\'\\\\x20\\'..=\\'\\\\x7e\\' => {\\n //\\n buf.push(c);\\n }\\n \\'\\\\u{7f}\\'..=\\'\\\\u{ff}\\' => {\\n buf.push(c);\\n }\\n\\n _ => {\\n buf.push(c);\\n }\\n }\\n }\\n\\n buf\\n}\\n',\n", + " 'content_id': 'f654ba42c9f6c5c87c607afaafb83aa65d0961b4',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/transforms/react/src/jsx/mod.rs',\n", + " 'size': 41801,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4226475279106858,\n", + " 'avg_line_length': 28.857142857142858,\n", + " 'blob_id': '0e702f1b25868154b95d25564c8e9c24132f6f87',\n", + " 'content': 'use rustc_hash::FxHashSet;\\nuse std::{\\n borrow::Cow,\\n mem::{replace, take},\\n};\\nuse swc_atoms::JsWord;\\nuse swc_common::{pass::CompilerPass, util::take::Take, Mark, Spanned, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::{pass::JsPass, perf::Check};\\nuse swc_ecma_transforms_macros::fast_path;\\nuse swc_ecma_utils::{\\n default_constructor, ident::IdentLike, prepend, private_ident, quote_ident, ExprFactory, Id,\\n};\\nuse swc_ecma_visit::{\\n as_folder, noop_visit_mut_type, noop_visit_type, Node, Visit, VisitMut, VisitMutWith, VisitWith,\\n};\\n\\n/// https://github.com/tc39/proposal-private-fields-in-in\\npub fn private_in_object() -> impl JsPass {\\n as_folder(PrivateInObject::default())\\n}\\n\\n#[derive(Debug)]\\nenum Mode {\\n ClassExpr {\\n vars: Vec,\\n init_exprs: Vec>,\\n },\\n ClassDecl {\\n vars: Vec,\\n },\\n}\\n\\nimpl Default for Mode {\\n fn default() -> Self {\\n Self::ClassDecl {\\n vars: Default::default(),\\n }\\n }\\n}\\n\\nimpl Mode {\\n fn push_var(&mut self, n: Ident, init: Option>) {\\n match self {\\n Mode::ClassExpr { vars, init_exprs } => {\\n vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(n.clone().into()),\\n init: None,\\n definite: Default::default(),\\n });\\n if let Some(init) = init {\\n init_exprs.push(Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(n.into()))),\\n right: init,\\n })));\\n }\\n }\\n Mode::ClassDecl { vars } => {\\n vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(n.into()),\\n init,\\n definite: Default::default(),\\n });\\n }\\n }\\n }\\n}\\n\\n#[derive(Default)]\\nstruct PrivateInObject {\\n vars: Vec,\\n prepend_exprs: Vec>,\\n\\n injected_vars: FxHashSet,\\n cls: ClassData,\\n}\\n\\n#[derive(Default)]\\nstruct ClassData {\\n ident: Option,\\n\\n vars: Mode,\\n\\n /// [Mark] for the current class.\\n ///\\n /// This is modified by the class visitor.\\n mark: Mark,\\n\\n privates: FxHashSet,\\n\\n /// Name of private methods.\\n methods: Vec,\\n\\n /// Name of private statics.\\n statics: Vec,\\n\\n consturctor_exprs: Vec>,\\n\\n names_used_for_brand_checks: FxHashSet,\\n}\\n\\nimpl CompilerPass for PrivateInObject {\\n fn name() -> Cow<\\'static, str> {\\n Cow::Borrowed(\"private-in-object\")\\n }\\n}\\n\\nimpl PrivateInObject {\\n fn var_name_for_brand_check(&self, n: &PrivateName) -> Ident {\\n let is_static = self.cls.statics.contains(&n.id.sym);\\n\\n let span = n.span.apply_mark(self.cls.mark);\\n\\n if !is_static && self.cls.methods.contains(&n.id.sym) {\\n if let Some(cls_name) = &self.cls.ident {\\n return Ident::new(format!(\"_brand_check_{}\", cls_name.sym).into(), span);\\n }\\n }\\n\\n Ident::new(format!(\"_brand_check_{}\", n.id.sym).into(), span)\\n }\\n}\\n\\n#[fast_path(ShouldWork)]\\nimpl VisitMut for PrivateInObject {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_class(&mut self, n: &mut Class) {\\n {\\n n.visit_children_with(&mut ClassAnalyzer {\\n brand_check_names: &mut self.cls.names_used_for_brand_checks,\\n ignore_class: true,\\n })\\n }\\n\\n for m in &n.body {\\n match m {\\n ClassMember::PrivateMethod(m) => {\\n self.cls.privates.insert(m.key.id.sym.clone());\\n\\n self.cls.methods.push(m.key.id.sym.clone());\\n\\n if m.is_static {\\n self.cls.statics.push(m.key.id.sym.clone());\\n }\\n }\\n\\n ClassMember::PrivateProp(m) => {\\n self.cls.privates.insert(m.key.id.sym.clone());\\n\\n if m.is_static {\\n self.cls.statics.push(m.key.id.sym.clone());\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n n.visit_mut_children_with(self);\\n\\n if !self.cls.consturctor_exprs.is_empty() {\\n let has_constructor = n\\n .body\\n .iter()\\n .any(|m| matches!(m, ClassMember::Constructor(_)));\\n\\n if !has_constructor {\\n let has_super = n.super_class.is_some();\\n n.body\\n .push(ClassMember::Constructor(default_constructor(has_super)));\\n }\\n\\n for m in &mut n.body {\\n match m {\\n ClassMember::Constructor(Constructor {\\n body: Some(body), ..\\n }) => {\\n for expr in take(&mut self.cls.consturctor_exprs) {\\n body.stmts.push(Stmt::Expr(ExprStmt {\\n span: DUMMY_SP,\\n expr,\\n }));\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n }\\n }\\n\\n fn visit_mut_class_decl(&mut self, n: &mut ClassDecl) {\\n let old_cls = take(&mut self.cls);\\n\\n self.cls.mark = Mark::fresh(Mark::root());\\n self.cls.ident = Some(n.ident.clone());\\n self.cls.vars = Mode::ClassDecl {\\n vars: Default::default(),\\n };\\n\\n n.visit_mut_children_with(self);\\n\\n match &mut self.cls.vars {\\n Mode::ClassDecl { vars } => {\\n self.vars.extend(take(vars));\\n }\\n _ => {\\n unreachable!()\\n }\\n }\\n\\n self.cls = old_cls;\\n }\\n\\n fn visit_mut_class_expr(&mut self, n: &mut ClassExpr) {\\n let old_cls = take(&mut self.cls);\\n\\n self.cls.mark = Mark::fresh(Mark::root());\\n self.cls.ident = n.ident.clone();\\n self.cls.vars = Mode::ClassExpr {\\n vars: Default::default(),\\n init_exprs: Default::default(),\\n };\\n\\n n.visit_mut_children_with(self);\\n\\n match &mut self.cls.vars {\\n Mode::ClassExpr { vars, init_exprs } => {\\n self.vars.extend(take(vars));\\n self.prepend_exprs.extend(take(init_exprs));\\n }\\n _ => {\\n unreachable!()\\n }\\n }\\n\\n self.cls = old_cls;\\n }\\n\\n fn visit_mut_assign_pat(&mut self, p: &mut AssignPat) {\\n p.left.visit_mut_with(self);\\n\\n {\\n let mut buf = FxHashSet::default();\\n let mut v = ClassAnalyzer {\\n brand_check_names: &mut buf,\\n ignore_class: false,\\n };\\n p.right.visit_with(p, &mut v);\\n\\n if buf.is_empty() {\\n p.right.visit_mut_with(self);\\n } else {\\n let mut bs = BlockStmt {\\n span: DUMMY_SP,\\n stmts: vec![],\\n };\\n bs.stmts.push(Stmt::Return(ReturnStmt {\\n span: DUMMY_SP,\\n arg: Some(p.right.take()),\\n }));\\n bs.visit_mut_with(self);\\n\\n p.right = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: ArrowExpr {\\n span: DUMMY_SP,\\n params: Default::default(),\\n body: BlockStmtOrExpr::BlockStmt(bs),\\n is_async: false,\\n is_generator: false,\\n type_params: Default::default(),\\n return_type: Default::default(),\\n }\\n .as_callee(),\\n args: Default::default(),\\n type_args: Default::default(),\\n }));\\n }\\n }\\n }\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n let prev_prepend_exprs = take(&mut self.prepend_exprs);\\n\\n e.visit_mut_children_with(self);\\n\\n let mut prepend_exprs = replace(&mut self.prepend_exprs, prev_prepend_exprs);\\n\\n if !prepend_exprs.is_empty() {\\n match e {\\n Expr::Seq(e) => {\\n e.exprs = prepend_exprs.into_iter().chain(e.exprs.take()).collect();\\n }\\n _ => {\\n prepend_exprs.push(Box::new(e.take()));\\n *e = Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs: prepend_exprs,\\n });\\n }\\n }\\n return;\\n }\\n\\n match e {\\n Expr::Bin(BinExpr {\\n span,\\n op: op!(\"in\"),\\n left,\\n right,\\n }) if left.is_private_name() => {\\n let left = left.take().expect_private_name();\\n\\n let is_static = self.cls.statics.contains(&left.id.sym);\\n let is_method = self.cls.methods.contains(&left.id.sym);\\n\\n if let Some(cls_ident) = self.cls.ident.clone() {\\n if is_static && is_method {\\n *e = Expr::Bin(BinExpr {\\n span: *span,\\n op: op!(\"===\"),\\n left: Box::new(Expr::Ident(cls_ident)),\\n right: right.take(),\\n });\\n return;\\n }\\n }\\n\\n let var_name = self.var_name_for_brand_check(&left);\\n\\n if self.cls.privates.contains(&left.id.sym)\\n && self.injected_vars.insert(var_name.to_id())\\n {\\n self.cls.vars.push_var(\\n var_name.clone(),\\n Some(Box::new(Expr::New(NewExpr {\\n span: DUMMY_SP,\\n callee: Box::new(Expr::Ident(quote_ident!(\"WeakSet\"))),\\n args: Some(Default::default()),\\n type_args: Default::default(),\\n }))),\\n );\\n\\n if is_method {\\n self.cls\\n .consturctor_exprs\\n .push(Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: var_name\\n .clone()\\n .make_member(quote_ident!(\"add\"))\\n .as_callee(),\\n args: vec![ThisExpr { span: DUMMY_SP }.as_arg()],\\n type_args: Default::default(),\\n })));\\n }\\n }\\n\\n *e = Expr::Call(CallExpr {\\n span: *span,\\n callee: var_name.make_member(quote_ident!(\"has\")).as_callee(),\\n args: vec![right.take().as_arg()],\\n type_args: Default::default(),\\n });\\n return;\\n }\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_member_expr(&mut self, e: &mut MemberExpr) {\\n e.obj.visit_mut_with(self);\\n\\n if e.computed {\\n e.obj.visit_mut_with(self);\\n }\\n }\\n\\n fn visit_mut_module_items(&mut self, ns: &mut Vec) {\\n ns.visit_mut_children_with(self);\\n\\n if !self.vars.is_empty() {\\n prepend(\\n ns,\\n ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: Default::default(),\\n decls: take(&mut self.vars),\\n }))),\\n );\\n }\\n }\\n\\n fn visit_mut_private_prop(&mut self, n: &mut PrivateProp) {\\n n.visit_mut_children_with(self);\\n\\n if self.cls.names_used_for_brand_checks.contains(&n.key.id.sym) {\\n let var_name = self.var_name_for_brand_check(&n.key);\\n\\n match &mut n.value {\\n Some(init) => {\\n let init_span = init.span();\\n\\n let tmp = private_ident!(\"_tmp\");\\n\\n self.cls.vars.push_var(tmp.clone(), None);\\n\\n let assign = Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n op: op!(\"=\"),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(tmp.clone().into()))),\\n right: init.take(),\\n }));\\n\\n let add_to_checker = Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: var_name\\n .clone()\\n .make_member(quote_ident!(\"add\"))\\n .as_callee(),\\n args: vec![ThisExpr { span: DUMMY_SP }.as_arg()],\\n type_args: Default::default(),\\n }));\\n\\n *init = Box::new(Expr::Seq(SeqExpr {\\n span: init_span,\\n exprs: vec![assign, add_to_checker, Box::new(tmp.clone().into())],\\n }));\\n }\\n None => {\\n n.value = Some(Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(\"void\"),\\n arg: Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: var_name\\n .clone()\\n .make_member(quote_ident!(\"add\"))\\n .as_callee(),\\n args: vec![ThisExpr { span: DUMMY_SP }.as_arg()],\\n type_args: Default::default(),\\n })),\\n })))\\n }\\n }\\n }\\n }\\n\\n fn visit_mut_prop_name(&mut self, n: &mut PropName) {\\n match n {\\n PropName::Computed(_) => {\\n n.visit_mut_children_with(self);\\n }\\n\\n _ => {}\\n }\\n }\\n\\n fn visit_mut_stmts(&mut self, s: &mut Vec) {\\n s.visit_mut_children_with(self);\\n\\n if !self.vars.is_empty() {\\n prepend(\\n s,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n declare: Default::default(),\\n decls: take(&mut self.vars),\\n })),\\n );\\n }\\n }\\n}\\n\\nstruct ClassAnalyzer<\\'a> {\\n brand_check_names: &\\'a mut FxHashSet,\\n ignore_class: bool,\\n}\\n\\nimpl Visit for ClassAnalyzer<\\'_> {\\n noop_visit_type!();\\n\\n fn visit_bin_expr(&mut self, n: &BinExpr, _: &dyn Node) {\\n n.visit_children_with(self);\\n\\n if n.op == op!(\"in\") {\\n match &*n.left {\\n Expr::PrivateName(left) => {\\n self.brand_check_names.insert(left.id.sym.clone());\\n }\\n\\n _ => {}\\n }\\n }\\n }\\n\\n /// Noop\\n fn visit_class(&mut self, n: &Class, _: &dyn Node) {\\n if self.ignore_class {\\n return;\\n }\\n\\n n.visit_children_with(self);\\n }\\n}\\n\\n#[derive(Default)]\\nstruct ShouldWork {\\n found: bool,\\n}\\n\\nimpl Check for ShouldWork {\\n fn should_handle(&self) -> bool {\\n self.found\\n }\\n}\\n\\nimpl Visit for ShouldWork {\\n noop_visit_type!();\\n\\n fn visit_bin_expr(&mut self, e: &BinExpr, _: &dyn Node) {\\n if e.op == op!(\"in\") && e.left.is_private_name() {\\n self.found = true;\\n return;\\n }\\n\\n e.visit_children_with(self);\\n }\\n\\n fn visit_private_method(&mut self, _: &PrivateMethod, _: &dyn Node) {\\n self.found = true;\\n }\\n\\n fn visit_private_prop(&mut self, _: &PrivateProp, _: &dyn Node) {\\n self.found = true;\\n }\\n}\\n',\n", + " 'content_id': '6b06c1aef997e49443bde3ec16b70ed712a83814',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/ecmascript/transforms/proposal/src/private_in_object.rs',\n", + " 'size': 16302,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6370967741935484,\n", + " 'avg_line_length': 31.476190476190474,\n", + " 'blob_id': '830a5daa8c5a097849cd0dfe514e3e170380a7fb',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"General ecmascript loader used for transforms\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_loader/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_loader\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.20.1\"\\n\\n[package.metadata.docs.rs]\\nall-features = true\\n\\n[features]\\ndefault = []\\n\\n# Enable node js resolver\\nnode = [\"normpath\", \"serde\", \"serde_json\", \"dashmap\", \"once_cell\", \"path-clean\"]\\n# Enable support for `paths` of tsconfig.json\\ntsc = [\"dashmap\", \"once_cell\", \"regex\"]\\n\\n[dependencies]\\nanyhow = \"1.0.41\"\\ndashmap = {version = \"4.0.2\", optional = true}\\nlru = {version = \"0.6.5\", optional = true}\\nonce_cell = {version = \"1.8.0\", optional = true}\\npath-clean = {version = \"=0.1.0\", optional = true}\\nregex = {version = \"1\", optional = true}\\nrustc-hash = \"1.1.0\"\\nserde = {version = \"1.0.126\", optional = true}\\nserde_json = {version = \"1.0.64\", optional = true}\\nswc_atoms = {version = \"0.2.3\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../visit\"}\\ntracing = \"0.1.28\"\\n\\n[dev-dependencies]\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\n\\n[target.\\'cfg(windows)\\'.dependencies]\\nnormpath = {version = \"0.2\", optional = true}\\n',\n", + " 'content_id': '6499453a27384f03ad655c71f9dddc33a3878f63',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 80,\n", + " 'path': '/ecmascript/loader/Cargo.toml',\n", + " 'size': 1364,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.3158595641646489,\n", + " 'avg_line_length': 41.32796486090776,\n", + " 'blob_id': '01a240039a5ba410cca730d6ae9c875bf1d6613d',\n", + " 'content': 'use crate::{\\n bundler::{\\n keywords::KeywordRenamer,\\n load::{Imports, TransformedModule},\\n },\\n dep_graph::ModuleGraph,\\n id::{Id, ModuleId},\\n inline::inline,\\n load::Load,\\n modules::Modules,\\n resolve::Resolve,\\n util::{CloneMap, ExprExt, VarDeclaratorExt},\\n Bundler, Hook, ModuleRecord,\\n};\\nuse anyhow::Error;\\nuse indexmap::IndexSet;\\nuse petgraph::EdgeDirection;\\nuse rustc_hash::{FxHashMap, FxHashSet, FxHasher};\\nuse std::{hash::BuildHasherDefault, sync::atomic::Ordering};\\nuse swc_atoms::js_word;\\nuse swc_common::{sync::Lock, FileName, SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{find_ids, prepend, private_ident, quote_ident, ExprFactory};\\nuse swc_ecma_visit::{noop_fold_type, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\nuse EdgeDirection::Outgoing;\\n\\npub(super) struct Ctx {\\n /// Full dependency graph.\\n pub graph: ModuleGraph,\\n pub cycles: Vec>,\\n pub transitive_remap: CloneMap,\\n pub export_stars_in_wrapped: Lock>>,\\n}\\n\\nimpl Ctx {\\n pub fn is_exported_ctxt(\\n &self,\\n ctxt_to_check: SyntaxContext,\\n entry_export_ctxt: SyntaxContext,\\n ) -> bool {\\n if ctxt_to_check == entry_export_ctxt {\\n return true;\\n }\\n\\n if let Some(v) = self.transitive_remap.get(&ctxt_to_check) {\\n if v == ctxt_to_check {\\n return false;\\n }\\n\\n return self.is_exported_ctxt(v, entry_export_ctxt);\\n }\\n\\n false\\n }\\n}\\n\\nimpl Bundler<\\'_, L, R>\\nwhere\\n L: Load,\\n R: Resolve,\\n{\\n pub(super) fn get_for_merging(\\n &self,\\n ctx: &Ctx,\\n id: ModuleId,\\n is_entry: bool,\\n ) -> Result {\\n self.run(|| {\\n let info = self\\n .scope\\n .get_module(id)\\n .unwrap_or_else(|| unreachable!(\"Module {} is not registered\", id));\\n let mut module = self.apply_hooks(id, is_entry)?;\\n module = self.prepare_for_merging(&ctx, &info, module)?;\\n\\n if !is_entry {\\n module = self.wrap_cjs_module(ctx, &info, module)?;\\n }\\n self.replace_cjs_require_calls(&info, &mut module, is_entry);\\n\\n Ok(module)\\n })\\n }\\n\\n /// This method sort modules.\\n pub(super) fn merge_into_entry(\\n &self,\\n ctx: &Ctx,\\n entry_id: ModuleId,\\n entry: &mut Modules,\\n all: &mut FxHashMap,\\n ) {\\n self.run(|| {\\n let injected_ctxt = self.injected_ctxt;\\n\\n let entry_info = self.scope.get_module(entry_id).unwrap();\\n\\n let all_deps_of_entry =\\n self.collect_all_deps(&ctx.graph, entry_id, &mut Default::default());\\n\\n tracing::debug!(\"Merging dependenciess: {:?}\", all_deps_of_entry);\\n\\n let deps = all_deps_of_entry.iter().map(|id| {\\n let dep_info = self.scope.get_module(*id).unwrap();\\n entry_info.helpers.extend(&dep_info.helpers);\\n entry_info.swc_helpers.extend_from(&dep_info.swc_helpers);\\n\\n if *id == entry_id {\\n return Modules::empty(injected_ctxt);\\n }\\n\\n all.remove(id).unwrap_or_else(|| {\\n unreachable!(\\n \"failed to merge into {}: module {} does not exist in the map\",\\n entry_id, id\\n )\\n })\\n });\\n\\n for dep in deps {\\n entry.add_dep(dep);\\n }\\n\\n self.replace_import_specifiers(&entry_info, entry);\\n self.finalize_merging_of_entry(ctx, entry_id, entry);\\n self.remove_wrong_exports(ctx, &entry_info, entry);\\n })\\n }\\n\\n fn collect_all_deps(\\n &self,\\n graph: &ModuleGraph,\\n start: ModuleId,\\n dejavu: &mut FxHashSet,\\n ) -> IndexSet> {\\n let mut set = IndexSet::default();\\n\\n for dep in graph.neighbors_directed(start, Outgoing) {\\n if !dejavu.insert(dep) {\\n continue;\\n }\\n set.insert(dep);\\n set.extend(self.collect_all_deps(graph, dep, dejavu));\\n }\\n\\n set\\n }\\n\\n pub(crate) fn apply_hooks(\\n &self,\\n module_id: ModuleId,\\n is_entry: bool,\\n ) -> Result {\\n self.run(|| {\\n let info = self.scope.get_module(module_id).unwrap();\\n\\n let mut entry: Module = (*info.module).clone();\\n entry.visit_mut_with(&mut ImportMetaHandler {\\n file: &info.fm.name,\\n hook: &self.hook,\\n is_entry,\\n inline_ident: private_ident!(\"importMeta\"),\\n occurred: false,\\n err: None,\\n });\\n\\n let module = Modules::from(module_id, entry, self.injected_ctxt);\\n\\n Ok(module)\\n })\\n }\\n\\n /// This should only be called after everything is merged.\\n ///\\n /// This method does not care about orders of statement, and it\\'s expected\\n /// to be called before `sort`.\\n fn inject_reexports(&self, ctx: &Ctx, _entry_id: ModuleId, entry: &mut Modules) {\\n // dbg!(&ctx.transitive_remap);\\n let injected_ctxt = self.injected_ctxt;\\n\\n {\\n // Handle `export *` for non-wrapped modules.\\n\\n let mut vars = vec![];\\n /// We recurse if `export *` is nested.\\n fn add_var(\\n injected_ctxt: SyntaxContext,\\n vars: &mut Vec<(ModuleId, ModuleItem)>,\\n declared: &mut FxHashSet,\\n map: &CloneMap,\\n module_id: ModuleId,\\n id: Id,\\n ) {\\n let remapped = match map.get(&id.ctxt()) {\\n Some(v) => v,\\n _ => return,\\n };\\n if remapped == id.ctxt() {\\n return;\\n }\\n let reexported = id.clone().with_ctxt(remapped);\\n\\n add_var(\\n injected_ctxt,\\n vars,\\n declared,\\n map,\\n module_id,\\n reexported.clone(),\\n );\\n\\n if !declared.insert(reexported.clone()) {\\n return;\\n }\\n\\n vars.push((\\n module_id,\\n id.assign_to(reexported)\\n .into_module_item(injected_ctxt, \"export_star_replacer\"),\\n ));\\n }\\n\\n // We have to exlcude some ids because there are already declared.\\n // See https://github.com/denoland/deno/issues/8725\\n //\\n // Let\\'s say D is a dependency which contains export * from \\'./foo\\';\\n // If an user import and export from D, the transitive syntax context map\\n // contains a entry from D to foo because it\\'s reexported and\\n // the variable (reexported from D) exist because it\\'s imported.\\n let mut declared_ids = FxHashSet::<_>::default();\\n\\n for (_, stmt) in entry.iter() {\\n match stmt {\\n ModuleItem::Stmt(Stmt::Decl(Decl::Var(decl))) => {\\n if decl.span.ctxt == injected_ctxt {\\n let ids: Vec = find_ids(decl);\\n declared_ids.extend(ids);\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n for (module_id, stmt) in entry.iter() {\\n match stmt {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(export)) => {\\n for s in &export.specifiers {\\n match s {\\n ExportSpecifier::Namespace(_) => {}\\n ExportSpecifier::Default(_) => {}\\n ExportSpecifier::Named(named) => match &named.exported {\\n Some(exported) => {\\n let id: Id = exported.into();\\n if declared_ids.contains(&id) {\\n continue;\\n }\\n\\n vars.push((\\n module_id,\\n named\\n .orig\\n .clone()\\n .assign_to(exported.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"finalize -> export to var\",\\n ),\\n ));\\n }\\n None => {}\\n },\\n }\\n }\\n }\\n\\n ModuleItem::Stmt(Stmt::Decl(Decl::Var(decl))) => {\\n let ids: Vec = find_ids(decl);\\n\\n for id in ids {\\n if *id.sym() == js_word!(\"default\") {\\n continue;\\n }\\n\\n add_var(\\n injected_ctxt,\\n &mut vars,\\n &mut declared_ids,\\n &ctx.transitive_remap,\\n module_id,\\n id,\\n );\\n }\\n }\\n\\n _ => {}\\n }\\n }\\n\\n entry.append_all(vars);\\n }\\n\\n {\\n let mut map = ctx.export_stars_in_wrapped.lock();\\n let mut additional_props = FxHashMap::<_, Vec<_>>::default();\\n // Handle `export *` for wrapped modules.\\n for (module_id, ctxts) in map.drain() {\\n for (_, stmt) in entry.iter() {\\n match stmt {\\n ModuleItem::Stmt(Stmt::Decl(Decl::Var(decl))) => {\\n let ids: Vec = find_ids(decl);\\n\\n for id in ids {\\n if *id.sym() == js_word!(\"default\") {\\n continue;\\n }\\n\\n if ctxts.contains(&id.ctxt()) {\\n additional_props.entry(module_id).or_default().push(\\n PropOrSpread::Prop(Box::new(Prop::Shorthand(\\n id.into_ident(),\\n ))),\\n );\\n }\\n }\\n }\\n _ => {}\\n }\\n }\\n }\\n\\n for (module_id, props) in additional_props {\\n let id = match self.scope.wrapped_esm_id(module_id) {\\n Some(v) => v,\\n None => continue,\\n };\\n\\n for (_, stmt) in entry.iter_mut() {\\n let var = match stmt {\\n ModuleItem::Stmt(Stmt::Decl(Decl::Var(\\n var\\n @\\n VarDecl {\\n kind: VarDeclKind::Const,\\n ..\\n },\\n ))) => var,\\n _ => continue,\\n };\\n\\n if var.decls.len() != 1 {\\n continue;\\n }\\n\\n let var_decl = &mut var.decls[0];\\n match &var_decl.name {\\n Pat::Ident(i) if id == i.id => {}\\n _ => continue,\\n }\\n\\n let callee = match &mut var_decl.init {\\n Some(init) => match &mut **init {\\n Expr::Call(CallExpr { callee, .. }) => match callee {\\n ExprOrSuper::Super(_) => continue,\\n ExprOrSuper::Expr(v) => v,\\n },\\n _ => continue,\\n },\\n None => continue,\\n };\\n\\n let f = match &mut **callee {\\n Expr::Fn(f) => f,\\n _ => continue,\\n };\\n\\n let body = match &mut f.function.body {\\n Some(body) => body,\\n None => continue,\\n };\\n\\n let last_stmt = body.stmts.last_mut();\\n\\n let return_stmt = match last_stmt {\\n Some(Stmt::Return(s)) => s,\\n _ => continue,\\n };\\n\\n let ret_val = match &mut return_stmt.arg {\\n Some(arg) => arg,\\n None => continue,\\n };\\n\\n let obj = match &mut **ret_val {\\n Expr::Object(obj) => obj,\\n _ => continue,\\n };\\n\\n obj.props.extend(props);\\n break;\\n }\\n }\\n }\\n }\\n\\n fn finalize_merging_of_entry(&self, ctx: &Ctx, id: ModuleId, entry: &mut Modules) {\\n tracing::trace!(\"All modules are merged\");\\n\\n tracing::debug!(\"Injecting reexports\");\\n self.inject_reexports(ctx, id, entry);\\n\\n // entry.print(&self.cm, \"before inline\");\\n\\n tracing::debug!(\"Inlining injected variables\");\\n\\n inline(self.injected_ctxt, entry);\\n\\n entry.sort(id, &ctx.graph, &ctx.cycles, &self.cm);\\n\\n // crate::debug::print_hygiene(\"done\", &self.cm, &entry.clone().into());\\n\\n entry.retain_mut(|_, item| {\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::ExportAll(export)) => {\\n if self.config.external_modules.contains(&export.src.value) {\\n return true;\\n }\\n\\n return false;\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(export)) => {\\n if let Some(src) = &export.src {\\n if self.config.external_modules.contains(&src.value) {\\n return true;\\n }\\n }\\n\\n export.specifiers.retain(|s| match s {\\n ExportSpecifier::Namespace(_) => false,\\n _ => true,\\n });\\n\\n export.src = None;\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => {\\n if self.config.external_modules.contains(&import.src.value) {\\n return true;\\n }\\n\\n // Drop import statements.\\n return false;\\n }\\n\\n _ => {}\\n }\\n\\n true\\n });\\n\\n tracing::debug!(\"Renaming keywords\");\\n\\n entry.visit_mut_with(&mut KeywordRenamer::default());\\n\\n // print_hygiene(\\n // \"done-clean\",\\n // &self.cm,\\n // &entry\\n // .clone()\\n // .fold_with(&mut hygiene())\\n // .fold_with(&mut fixer(None)),\\n // );\\n }\\n\\n /// Remove exports with wrong syntax context\\n fn remove_wrong_exports(&self, ctx: &Ctx, info: &TransformedModule, module: &mut Modules) {\\n tracing::debug!(\"Removing wrong exports\");\\n\\n let item_count = module.iter().count();\\n tracing::trace!(\"Item count = {}\", item_count);\\n\\n module.retain_mut(|_, item| {\\n match item {\\n // TODO: Handle export default\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {\\n specifiers, ..\\n })) => {\\n specifiers.retain(|s| match s {\\n ExportSpecifier::Named(ExportNamedSpecifier {\\n exported: Some(exported),\\n ..\\n }) => {\\n // Default is not exported via `export *`\\n if exported.sym == js_word!(\"default\") {\\n exported.span.ctxt == info.export_ctxt()\\n } else {\\n ctx.is_exported_ctxt(exported.span.ctxt, info.export_ctxt())\\n }\\n }\\n _ => true,\\n });\\n\\n if specifiers.is_empty() {\\n return false;\\n }\\n }\\n\\n _ => {}\\n }\\n\\n true\\n });\\n\\n tracing::debug!(\"Removed wrong exports\");\\n }\\n\\n /// This method handles imports and exports.\\n ///\\n ///\\n /// Basically one module have two top-level contexts. One is for it\\'s codes\\n /// and another is for exporting. This method connects two module by\\n /// injecting `const local_A = exported_B_from_foo;`\\n ///\\n ///\\n /// We convert all exports to variable at here.\\n pub(super) fn prepare_for_merging(\\n &self,\\n ctx: &Ctx,\\n info: &TransformedModule,\\n mut module: Modules,\\n ) -> Result {\\n self.handle_imports_and_exports(ctx, info, &mut module);\\n\\n let wrapped = self.scope.should_be_wrapped_with_a_fn(info.id);\\n if wrapped {\\n module = self.wrap_esm(ctx, info.id, module)?;\\n }\\n\\n // if !is_entry {\\n // module = module.fold_with(&mut Unexporter);\\n // }\\n\\n Ok(module)\\n }\\n\\n fn handle_imports_and_exports(\\n &self,\\n ctx: &Ctx,\\n info: &TransformedModule,\\n module: &mut Modules,\\n ) {\\n let injected_ctxt = self.injected_ctxt;\\n\\n if !info.is_es6 {\\n return;\\n }\\n\\n let mut extra = vec![];\\n\\n module.map_any_items(|_, items| {\\n let mut new = Vec::with_capacity(items.len() * 11 / 10);\\n\\n for item in items {\\n match item {\\n ModuleItem::ModuleDecl(ModuleDecl::Import(mut import)) => {\\n // Preserve imports from node.js builtin modules.\\n if self.config.external_modules.contains(&import.src.value) {\\n new.push(ModuleItem::ModuleDecl(ModuleDecl::Import(import)));\\n continue;\\n }\\n\\n if let Some((src, _)) = info\\n .imports\\n .specifiers\\n .iter()\\n .find(|s| s.0.src.value == import.src.value)\\n {\\n if !self.scope.get_module(src.module_id).unwrap().is_es6 {\\n new.push(ModuleItem::ModuleDecl(ModuleDecl::Import(import)));\\n continue;\\n }\\n }\\n\\n // Imports are easy to handle.\\n for s in &import.specifiers {\\n match s {\\n ImportSpecifier::Named(s) => match &s.imported {\\n Some(imported) => {\\n new.push(\\n imported\\n .clone()\\n .assign_to(s.local.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"prepare -> named import -> aliased\",\\n ),\\n );\\n }\\n None => {}\\n },\\n ImportSpecifier::Default(s) => {\\n new.push(\\n Ident::new(js_word!(\"default\"), import.span)\\n .assign_to(s.local.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"prepare -> default import\",\\n ),\\n );\\n }\\n ImportSpecifier::Namespace(s) => {\\n if let Some((src, _)) = info\\n .imports\\n .specifiers\\n .iter()\\n .find(|s| s.0.src.value == import.src.value)\\n {\\n let esm_id =\\n self.scope.wrapped_esm_id(src.module_id).expect(\\n \"If a namespace impoet specifier is preserved, it \\\\\\n means failutre of deblobbing and as a result \\\\\\n module should be marked as wrpaped esm\",\\n );\\n new.push(\\n esm_id\\n .clone()\\n .assign_to(s.local.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"prepare -> import -> namespace\",\\n ),\\n );\\n }\\n }\\n }\\n }\\n\\n import.specifiers.clear();\\n new.push(ModuleItem::ModuleDecl(ModuleDecl::Import(import)));\\n }\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(export)) => {\\n // At here, we create multiple items.\\n //\\n // One item is `const local_default = expr` and another one is\\n // `export { local_default as default }`.\\n //\\n // To allow using identifier of the declaration in the originsl module, we\\n // create `const local_default = orig_ident` if original identifier exists.\\n\\n let local =\\n Ident::new(js_word!(\"default\"), DUMMY_SP.with_ctxt(info.local_ctxt()));\\n\\n match export.decl {\\n DefaultDecl::Class(c) => {\\n //\\n match c.ident {\\n Some(ident) => {\\n new.push(ModuleItem::Stmt(Stmt::Decl(Decl::Class(\\n ClassDecl {\\n ident: ident.clone(),\\n class: c.class,\\n declare: false,\\n },\\n ))));\\n\\n new.push(ident.assign_to(local.clone()).into_module_item(\\n injected_ctxt,\\n \"prepare -> export default decl -> class -> with ident\",\\n ))\\n }\\n None => {\\n let init = Expr::Class(c);\\n new.push(init.assign_to(local.clone()).into_module_item(\\n injected_ctxt,\\n \"prepare -> export default decl -> class -> without \\\\\\n ident\",\\n ));\\n }\\n }\\n }\\n DefaultDecl::Fn(f) => {\\n //\\n match f.ident {\\n Some(ident) => {\\n new.push(ModuleItem::Stmt(Stmt::Decl(Decl::Fn(FnDecl {\\n ident: ident.clone(),\\n function: f.function,\\n declare: false,\\n }))));\\n\\n new.push(ident.assign_to(local.clone()).into_module_item(\\n injected_ctxt,\\n \"prepare -> export default decl -> function -> with \\\\\\n ident\",\\n ))\\n }\\n None => {\\n // We should inject a function declaration because of\\n // dependencies.\\n //\\n // See: https://github.com/denoland/deno/issues/9346\\n let ident = private_ident!(\"default\");\\n new.push(ModuleItem::Stmt(Stmt::Decl(Decl::Fn(FnDecl {\\n ident: ident.clone(),\\n function: f.function,\\n declare: false,\\n }))));\\n\\n new.push(ident.assign_to(local.clone()).into_module_item(\\n injected_ctxt,\\n \"prepare -> export default decl -> function -> \\\\\\n without ident\",\\n ));\\n }\\n }\\n }\\n DefaultDecl::TsInterfaceDecl(_) => continue,\\n }\\n\\n // Create `export { local_default as default }`\\n tracing::trace!(\\n \"Exporting `default` with `export default decl` ({})\",\\n local.sym\\n );\\n\\n let exported =\\n Ident::new(js_word!(\"default\"), DUMMY_SP.with_ctxt(info.export_ctxt()));\\n\\n new.push(\\n local\\n .clone()\\n .assign_to(exported.clone())\\n .into_module_item(injected_ctxt, \"prepare -> export default decl\"),\\n );\\n\\n let specifier = ExportSpecifier::Named(ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: local,\\n exported: Some(exported),\\n is_type_only: false,\\n });\\n extra.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span: export.span.with_ctxt(injected_ctxt),\\n specifiers: vec![specifier],\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )));\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(export)) => {\\n // At here, we create two items.\\n //\\n // One item is `const local_default = expr` and the\\n // other is `export { local_default as default }`.\\n\\n // TODO: Check if we really need this.\\n\\n let local =\\n Ident::new(js_word!(\"default\"), DUMMY_SP.with_ctxt(info.local_ctxt()));\\n\\n // Create `const local_default = expr`\\n new.push(\\n export\\n .expr\\n .assign_to(local.clone())\\n .into_module_item(injected_ctxt, \"prepare -> export default expr\"),\\n );\\n\\n let exported =\\n Ident::new(js_word!(\"default\"), DUMMY_SP.with_ctxt(info.export_ctxt()));\\n\\n new.push(\\n local\\n .clone()\\n .assign_to(exported.clone())\\n .into_module_item(injected_ctxt, \"prepare -> export default expr\"),\\n );\\n\\n // Create `export { local_default as default }`\\n let specifier = ExportSpecifier::Named(ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: local,\\n exported: Some(exported),\\n is_type_only: false,\\n });\\n tracing::trace!(\"Exporting `default` with `export default expr`\");\\n extra.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span: export.span.with_ctxt(injected_ctxt),\\n specifiers: vec![specifier],\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )));\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => {\\n // Idea is almost same as above. But we uses symbol of the declaration\\n // instead of using `default`.\\n\\n let local = match export.decl {\\n Decl::Class(c) => {\\n let i = c.ident.clone();\\n new.push(ModuleItem::Stmt(Stmt::Decl(Decl::Class(c))));\\n\\n i\\n }\\n Decl::Fn(f) => {\\n let i = f.ident.clone();\\n new.push(ModuleItem::Stmt(Stmt::Decl(Decl::Fn(f))));\\n\\n i\\n }\\n Decl::Var(v) => {\\n let ids: Vec = find_ids(&v);\\n //\\n\\n new.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(v))));\\n\\n let export =\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {\\n span: export.span.with_ctxt(injected_ctxt),\\n specifiers: ids\\n .into_iter()\\n .map(|id| {\\n let exported = Ident::new(\\n id.sym.clone(),\\n id.span.with_ctxt(info.export_ctxt()),\\n );\\n\\n tracing::trace!(\\n \"Exporting `{}{:?}` with `export decl`\",\\n id.sym,\\n id.span.ctxt\\n );\\n\\n new.push(\\n id.clone()\\n .assign_to(exported.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"prepare -> export decl -> var\",\\n ),\\n );\\n\\n ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: id,\\n exported: Some(exported),\\n is_type_only: false,\\n }\\n })\\n .map(ExportSpecifier::Named)\\n .collect(),\\n src: None,\\n type_only: false,\\n asserts: None,\\n }));\\n extra.push(export);\\n continue;\\n }\\n\\n Decl::TsInterface(_)\\n | Decl::TsTypeAlias(_)\\n | Decl::TsEnum(_)\\n | Decl::TsModule(_) => continue,\\n };\\n\\n tracing::trace!(\\n \"Exporting `default` with `export default decl` ({})\",\\n local.sym\\n );\\n\\n // Create `export { local_ident as exported_ident }`\\n let exported =\\n Ident::new(local.sym.clone(), local.span.with_ctxt(info.export_ctxt()));\\n\\n new.push(\\n local\\n .clone()\\n .assign_to(exported.clone())\\n .into_module_item(injected_ctxt, \"prepare -> export decl -> var\"),\\n );\\n\\n let specifier = ExportSpecifier::Named(ExportNamedSpecifier {\\n span: DUMMY_SP,\\n orig: local,\\n exported: Some(exported),\\n is_type_only: false,\\n });\\n\\n extra.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(\\n NamedExport {\\n span: export.span.with_ctxt(injected_ctxt),\\n specifiers: vec![specifier],\\n src: None,\\n type_only: false,\\n asserts: None,\\n },\\n )));\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {\\n ref specifiers,\\n ref src,\\n ..\\n })) => {\\n if let Some(export_src) = src {\\n if let Some((src, _)) = info\\n .exports\\n .reexports\\n .iter()\\n .find(|s| s.0.src.value == export_src.value)\\n {\\n let dep = self.scope.get_module(src.module_id).unwrap();\\n if !dep.is_es6 {\\n dep.helpers.require.store(true, Ordering::SeqCst);\\n\\n let mut vars = vec![];\\n let mod_var = private_ident!(\"_cjs_module_\");\\n\\n vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(mod_var.clone().into()),\\n init: Some(Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: Ident::new(\\n \"load\".into(),\\n DUMMY_SP.with_ctxt(dep.export_ctxt()),\\n )\\n .as_callee(),\\n args: Default::default(),\\n type_args: Default::default(),\\n }))),\\n definite: Default::default(),\\n });\\n for s in specifiers {\\n match s {\\n ExportSpecifier::Namespace(s) => {\\n vars.push(VarDeclarator {\\n span: s.span,\\n name: Pat::Ident(s.name.clone().into()),\\n init: Some(Box::new(Expr::Ident(\\n mod_var.clone(),\\n ))),\\n definite: Default::default(),\\n });\\n }\\n ExportSpecifier::Default(s) => {\\n vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(s.exported.clone().into()),\\n init: Some(Box::new(\\n mod_var\\n .clone()\\n .make_member(quote_ident!(\"default\")),\\n )),\\n definite: Default::default(),\\n });\\n }\\n ExportSpecifier::Named(s) => {\\n vars.push(VarDeclarator {\\n span: s.span,\\n name: Pat::Ident(\\n s.exported.clone().unwrap().into(),\\n ),\\n init: Some(Box::new(\\n mod_var.clone().make_member(s.orig.clone()),\\n )),\\n definite: Default::default(),\\n });\\n }\\n }\\n }\\n\\n if !vars.is_empty() {\\n new.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(\\n VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Const,\\n declare: Default::default(),\\n decls: vars,\\n },\\n ))));\\n }\\n continue;\\n }\\n }\\n }\\n\\n for s in specifiers {\\n match s {\\n ExportSpecifier::Named(ExportNamedSpecifier {\\n orig,\\n exported: Some(exported),\\n ..\\n }) => {\\n new.push(\\n orig.clone().assign_to(exported.clone()).into_module_item(\\n injected_ctxt,\\n \"prepare -> export named -> aliased\",\\n ),\\n );\\n }\\n\\n ExportSpecifier::Default(ExportDefaultSpecifier {\\n exported,\\n ..\\n }) => {\\n new.push(\\n Ident::new(\\n js_word!(\"default\"),\\n DUMMY_SP.with_ctxt(info.local_ctxt()),\\n )\\n .clone()\\n .assign_to(exported.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"prepare -> export named -> aliased\",\\n ),\\n );\\n }\\n\\n ExportSpecifier::Namespace(ns) => {\\n if let Some((src, _)) = info\\n .exports\\n .reexports\\n .iter()\\n .find(|s| s.0.src.value == src.as_ref().unwrap().value)\\n {\\n if !self.scope.get_module(src.module_id).unwrap().is_es6 {\\n continue;\\n }\\n\\n let wrapped_esm_id =\\n self.scope.wrapped_esm_id(src.module_id);\\n match wrapped_esm_id {\\n Some(module_var) => {\\n // Create variable for the namespaced export.\\n extra.push(\\n module_var\\n .clone()\\n .assign_to(ns.name.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"prepare -> namespaced reexport\",\\n ),\\n );\\n let specifier =\\n ExportSpecifier::Named(ExportNamedSpecifier {\\n span: ns.span,\\n orig: module_var.into(),\\n exported: Some(ns.name.clone()),\\n is_type_only: false,\\n });\\n extra.push(ModuleItem::ModuleDecl(\\n ModuleDecl::ExportNamed(NamedExport {\\n span: ns.span,\\n specifiers: vec![specifier],\\n src: None,\\n asserts: None,\\n type_only: false,\\n }),\\n ));\\n }\\n None => {\\n unreachable!(\\n \"Modules rexported with `export * as foo from \\\\\\n \\'./foo\\'` should be marked as a wrapped esm\"\\n )\\n }\\n }\\n\\n // Remove `export * as foo from \\'\\'`\\n continue;\\n }\\n }\\n _ => {}\\n }\\n }\\n\\n new.push(item);\\n }\\n\\n ModuleItem::ModuleDecl(ModuleDecl::ExportAll(ref export)) => {\\n let export_ctxt = export.span.ctxt;\\n let reexport = self.scope.get_module(info.id).unwrap().export_ctxt();\\n ctx.transitive_remap.insert(export_ctxt, reexport);\\n\\n new.push(item);\\n }\\n\\n _ => {\\n new.push(item);\\n }\\n }\\n }\\n\\n new\\n });\\n\\n for item in extra {\\n module.append(info.id, item);\\n }\\n\\n // module.print(&self.cm, \"prepare\");\\n }\\n\\n pub(super) fn replace_import_specifiers(&self, info: &TransformedModule, module: &mut Modules) {\\n let injected_ctxt = self.injected_ctxt;\\n\\n let mut vars = vec![];\\n module.map_any_items(|module_id, stmts| {\\n let mut new = Vec::with_capacity(stmts.len() + 32);\\n\\n for stmt in stmts {\\n match &stmt {\\n ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => {\\n if self.config.external_modules.contains(&import.src.value) {\\n new.push(stmt);\\n continue;\\n }\\n\\n for specifier in &import.specifiers {\\n match specifier {\\n ImportSpecifier::Named(named) => match &named.imported {\\n Some(imported) => {\\n vars.push((\\n module_id,\\n imported\\n .clone()\\n .assign_to(named.local.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"from_replace_import_specifiers\",\\n ),\\n ));\\n continue;\\n }\\n None => {}\\n },\\n ImportSpecifier::Default(default) => {\\n if let Some((src, _)) = info\\n .imports\\n .specifiers\\n .iter()\\n .find(|s| s.0.src.value == import.src.value)\\n {\\n let imported = Ident::new(\\n js_word!(\"default\"),\\n DUMMY_SP.with_ctxt(src.export_ctxt),\\n );\\n vars.push((\\n module_id,\\n imported\\n .assign_to(default.local.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"from_replace_import_specifiers\",\\n ),\\n ));\\n continue;\\n }\\n }\\n ImportSpecifier::Namespace(s) => {\\n if let Some((src, _)) = info\\n .imports\\n .specifiers\\n .iter()\\n .find(|s| s.0.src.value == import.src.value)\\n {\\n let esm_id =\\n self.scope.wrapped_esm_id(src.module_id).expect(\\n \"If a namespace impoet specifier is preserved, it \\\\\\n means failutre of deblobbing and as a result \\\\\\n module should be marked as wrpaped esm\",\\n );\\n vars.push((\\n module_id,\\n esm_id\\n .clone()\\n .assign_to(s.local.clone())\\n .into_module_item(\\n injected_ctxt,\\n \"from_replace_import_specifiers: namespaced\",\\n ),\\n ));\\n continue;\\n }\\n }\\n }\\n }\\n\\n // We should remove imports\\n continue;\\n }\\n _ => {}\\n }\\n\\n new.push(stmt);\\n }\\n\\n new\\n });\\n\\n module.append_all(vars)\\n }\\n}\\n\\npub(super) struct ImportDropper<\\'a> {\\n pub imports: &\\'a Imports,\\n}\\n\\nimpl VisitMut for ImportDropper<\\'_> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_module_item(&mut self, i: &mut ModuleItem) {\\n match i {\\n ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl { src, .. }))\\n if self\\n .imports\\n .specifiers\\n .iter()\\n .any(|(s, _)| s.src.value == *src.value) =>\\n {\\n *i = ModuleItem::Stmt(Stmt::Empty(EmptyStmt { span: DUMMY_SP }))\\n }\\n _ => {}\\n }\\n }\\n}\\n\\n/// `export var a = 1` => `var a = 1`\\npub(super) struct Unexporter;\\n\\nimpl Fold for Unexporter {\\n noop_fold_type!();\\n\\n fn fold_module_item(&mut self, item: ModuleItem) -> ModuleItem {\\n match item {\\n ModuleItem::ModuleDecl(decl) => match decl {\\n ModuleDecl::ExportDecl(decl) => ModuleItem::Stmt(Stmt::Decl(decl.decl)),\\n\\n ModuleDecl::ExportDefaultDecl(export) => match export.decl {\\n DefaultDecl::Class(ClassExpr { ident: None, .. })\\n | DefaultDecl::Fn(FnExpr { ident: None, .. }) => {\\n ModuleItem::Stmt(Stmt::Empty(EmptyStmt { span: DUMMY_SP }))\\n }\\n DefaultDecl::TsInterfaceDecl(decl) => {\\n ModuleItem::Stmt(Stmt::Decl(Decl::TsInterface(decl)))\\n }\\n\\n DefaultDecl::Class(ClassExpr {\\n ident: Some(ident),\\n class,\\n }) => ModuleItem::Stmt(Stmt::Decl(Decl::Class(ClassDecl {\\n declare: false,\\n ident,\\n class,\\n }))),\\n\\n DefaultDecl::Fn(FnExpr {\\n ident: Some(ident),\\n function,\\n }) => ModuleItem::Stmt(Stmt::Decl(Decl::Fn(FnDecl {\\n declare: false,\\n function,\\n ident,\\n }))),\\n },\\n\\n // Empty statement\\n ModuleDecl::ExportAll(..)\\n | ModuleDecl::ExportDefaultExpr(..)\\n | ModuleDecl::ExportNamed(..) => {\\n ModuleItem::Stmt(Stmt::Empty(EmptyStmt { span: DUMMY_SP }))\\n }\\n ModuleDecl::Import(..) => ModuleItem::ModuleDecl(decl),\\n\\n _ => unimplemented!(\"Unexported: {:?}\", decl),\\n },\\n\\n _ => item,\\n }\\n }\\n}\\n\\nstruct ImportMetaHandler<\\'a, \\'b> {\\n file: &\\'a FileName,\\n hook: &\\'a Box,\\n is_entry: bool,\\n inline_ident: Ident,\\n occurred: bool,\\n /// TODO: Use this\\n #[allow(dead_code)]\\n err: Option,\\n}\\n\\nimpl VisitMut for ImportMetaHandler<\\'_, \\'_> {\\n fn visit_mut_module(&mut self, n: &mut Module) {\\n n.visit_mut_children_with(self);\\n\\n if self.occurred {\\n match self.hook.get_import_meta_props(\\n n.span,\\n &ModuleRecord {\\n file_name: self.file.to_owned(),\\n is_entry: self.is_entry,\\n },\\n ) {\\n Ok(key_value_props) => {\\n prepend(\\n &mut n.body,\\n ModuleItem::Stmt(Stmt::Decl(Decl::Var(VarDecl {\\n span: n.span,\\n kind: VarDeclKind::Const,\\n declare: false,\\n decls: vec![VarDeclarator {\\n span: n.span,\\n name: Pat::Ident(self.inline_ident.clone().into()),\\n init: Some(Box::new(Expr::Object(ObjectLit {\\n span: n.span,\\n props: key_value_props\\n .iter()\\n .cloned()\\n .map(|kv| PropOrSpread::Prop(Box::new(Prop::KeyValue(kv))))\\n .collect(),\\n }))),\\n definite: false,\\n }],\\n }))),\\n );\\n }\\n Err(err) => self.err = Some(err),\\n }\\n }\\n }\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n e.visit_mut_children_with(self);\\n\\n match e {\\n Expr::MetaProp(MetaPropExpr {\\n meta:\\n Ident {\\n sym: js_word!(\"import\"),\\n ..\\n },\\n prop:\\n Ident {\\n sym: js_word!(\"meta\"),\\n ..\\n },\\n ..\\n }) => {\\n *e = Expr::Ident(self.inline_ident.clone());\\n self.occurred = true;\\n }\\n _ => {}\\n }\\n }\\n}\\n',\n", + " 'content_id': '9d92cbfa91731bb5906bbe99e0516e924e6d44b7',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 100,\n", + " 'path': '/bundler/src/bundler/chunk/merge.rs',\n", + " 'size': 57820,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.327668443624995,\n", + " 'avg_line_length': 33.74791086350975,\n", + " 'blob_id': '799138051b01c65a3c0bab8421bfb97423369113',\n", + " 'content': 'use rustc_hash::FxHashSet;\\nuse std::{iter, mem};\\nuse swc_atoms::JsWord;\\nuse swc_common::{util::take::Take, Mark, Spanned, SyntaxContext, DUMMY_SP};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_transforms_base::{\\n ext::{AsOptExpr, PatOrExprExt},\\n helper,\\n};\\nuse swc_ecma_utils::{alias_ident_for, alias_if_required, prepend, quote_ident, ExprFactory};\\nuse swc_ecma_visit::{noop_fold_type, noop_visit_mut_type, Fold, FoldWith, VisitMut, VisitMutWith};\\n\\npub(super) struct BrandCheckHandler<\\'a> {\\n /// Mark for the private `WeakSet` variable.\\n pub mark: Mark,\\n\\n pub class_name: &\\'a Ident,\\n\\n /// Private names used for brand checks.\\n pub names: &\\'a mut FxHashSet,\\n\\n pub statics: &\\'a FxHashSet,\\n}\\n\\nimpl VisitMut for BrandCheckHandler<\\'_> {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_expr(&mut self, e: &mut Expr) {\\n e.visit_mut_children_with(self);\\n\\n match e {\\n Expr::Bin(BinExpr {\\n span,\\n op: op!(\"in\"),\\n left,\\n right,\\n }) if left.is_private_name() => {\\n let n = match &**left {\\n Expr::PrivateName(ref n) => n,\\n _ => {\\n unreachable!()\\n }\\n };\\n match &**right {\\n Expr::Ident(right) => {\\n if self.class_name.sym == right.sym\\n && self.class_name.span.ctxt == right.span.ctxt\\n {\\n *e = Expr::Bin(BinExpr {\\n span: *span,\\n op: op!(\"===\"),\\n left: Box::new(Expr::Ident(self.class_name.clone())),\\n right: Box::new(Expr::Ident(right.clone())),\\n });\\n return;\\n }\\n }\\n _ => {}\\n }\\n\\n self.names.insert(n.id.sym.clone());\\n\\n let is_static = self.statics.contains(&n.id.sym);\\n\\n if is_static {\\n *e = Expr::Bin(BinExpr {\\n span: *span,\\n op: op!(\"===\"),\\n left: right.take(),\\n right: Box::new(Expr::Ident(self.class_name.clone())),\\n });\\n return;\\n }\\n\\n let weak_coll_ident = Ident::new(\\n format!(\"_{}\", n.id.sym).into(),\\n n.id.span.apply_mark(self.mark),\\n );\\n\\n *e = Expr::Call(CallExpr {\\n span: *span,\\n callee: weak_coll_ident.make_member(quote_ident!(\"has\")).as_callee(),\\n args: vec![right.take().as_arg()],\\n type_args: Default::default(),\\n });\\n }\\n\\n _ => {}\\n }\\n }\\n}\\n\\npub(super) struct FieldAccessFolder<\\'a> {\\n /// Mark for the private `WeakSet` variable.\\n pub mark: Mark,\\n pub method_mark: Mark,\\n\\n pub class_name: &\\'a Ident,\\n pub private_methods: &\\'a FxHashSet,\\n pub vars: Vec,\\n pub statics: &\\'a FxHashSet,\\n pub in_assign_pat: bool,\\n}\\n\\nmacro_rules! take_vars {\\n ($name:ident, $T:tt) => {\\n fn $name(&mut self, f: $T) -> $T {\\n assert!(self.vars.is_empty());\\n if f.body.is_none() {\\n return f;\\n }\\n\\n let mut f = f.fold_children_with(self);\\n\\n if !self.vars.is_empty() {\\n prepend(\\n &mut f.body.as_mut().unwrap().stmts,\\n Stmt::Decl(Decl::Var(VarDecl {\\n span: DUMMY_SP,\\n kind: VarDeclKind::Var,\\n decls: mem::replace(&mut self.vars, vec![]),\\n\\n declare: false,\\n })),\\n )\\n }\\n\\n f\\n }\\n };\\n}\\n\\nimpl<\\'a> Fold for FieldAccessFolder<\\'a> {\\n noop_fold_type!();\\n\\n take_vars!(fold_function, Function);\\n take_vars!(fold_constructor, Constructor);\\n\\n fn fold_expr(&mut self, e: Expr) -> Expr {\\n match e {\\n Expr::Update(UpdateExpr {\\n span,\\n prefix,\\n op,\\n arg,\\n }) if arg.is_member() => {\\n let arg = arg.member().unwrap().fold_with(self);\\n\\n let n = match *arg.prop {\\n Expr::PrivateName(ref n) => n,\\n _ => {\\n return Expr::Update(UpdateExpr {\\n span,\\n prefix,\\n op,\\n arg: Box::new(Expr::Member(arg)),\\n })\\n .fold_children_with(self);\\n }\\n };\\n\\n let obj = match arg.obj {\\n ExprOrSuper::Super(..) => {\\n return Expr::Update(UpdateExpr {\\n span,\\n prefix,\\n op,\\n arg: Box::new(Expr::Member(arg)),\\n })\\n .fold_children_with(self);\\n }\\n ExprOrSuper::Expr(ref obj) => obj.clone(),\\n };\\n\\n let is_static = self.statics.contains(&n.id.sym);\\n let ident = Ident::new(\\n format!(\"_{}\", n.id.sym).into(),\\n n.id.span.apply_mark(self.mark),\\n );\\n\\n let var = alias_ident_for(&obj, \"_ref\");\\n\\n let this = if match *obj {\\n Expr::This(..) => true,\\n _ => false,\\n } {\\n ThisExpr { span: DUMMY_SP }.as_arg()\\n } else if is_static {\\n obj.as_arg()\\n } else {\\n self.vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(var.clone().into()),\\n init: None,\\n definite: false,\\n });\\n AssignExpr {\\n span: obj.span(),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(var.clone().into()))),\\n op: op!(\"=\"),\\n right: obj,\\n }\\n .as_arg()\\n };\\n // Used iff !prefix\\n let old_var = alias_ident_for(&arg.prop, \"old\");\\n if !prefix {\\n self.vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(old_var.clone().into()),\\n init: None,\\n definite: false,\\n });\\n }\\n\\n let value = {\\n let arg = Box::new(self.fold_private_get(arg, Some(var)).0);\\n let left = Box::new(Expr::Unary(UnaryExpr {\\n span: DUMMY_SP,\\n op: op!(unary, \"+\"),\\n arg,\\n }));\\n let left = if prefix {\\n left\\n } else {\\n Box::new(Expr::Assign(AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(old_var.clone().into()))),\\n op: op!(\"=\"),\\n right: left,\\n }))\\n };\\n\\n BinExpr {\\n span: DUMMY_SP,\\n left,\\n op: match op {\\n op!(\"++\") => op!(bin, \"+\"),\\n op!(\"--\") => op!(bin, \"-\"),\\n },\\n right: Box::new(Expr::Lit(Lit::Num(Number {\\n span: DUMMY_SP,\\n value: 1.0,\\n }))),\\n }\\n .as_arg()\\n };\\n\\n let expr = if is_static {\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(\\n class_static_private_field_spec_set,\\n \"classStaticPrivateFieldSpecSet\"\\n ),\\n args: vec![\\n this,\\n self.class_name.clone().as_arg(),\\n ident.as_arg(),\\n value,\\n ],\\n\\n type_args: Default::default(),\\n })\\n } else {\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(class_private_field_set, \"classPrivateFieldSet\"),\\n args: vec![this, ident.as_arg(), value],\\n\\n type_args: Default::default(),\\n })\\n };\\n\\n if prefix {\\n expr\\n } else {\\n Expr::Seq(SeqExpr {\\n span: DUMMY_SP,\\n exprs: vec![Box::new(expr), Box::new(Expr::Ident(old_var))],\\n })\\n }\\n }\\n\\n Expr::Assign(AssignExpr {\\n span,\\n left,\\n op,\\n right,\\n }) if left.as_expr().is_some() && left.as_expr().unwrap().is_member() => {\\n let left = left.normalize_expr();\\n let left: MemberExpr = left.expr().unwrap().member().unwrap().fold_with(self);\\n let right = right.fold_with(self);\\n\\n let n = match *left.prop {\\n Expr::PrivateName(ref n) => n.clone(),\\n _ => {\\n return Expr::Assign(AssignExpr {\\n span,\\n left: PatOrExpr::Expr(Box::new(Expr::Member(left))),\\n op,\\n right,\\n })\\n .fold_children_with(self);\\n }\\n };\\n\\n let obj = match left.obj {\\n ExprOrSuper::Super(..) => {\\n return Expr::Assign(AssignExpr {\\n span,\\n left: PatOrExpr::Expr(Box::new(Expr::Member(MemberExpr {\\n prop: Box::new(Expr::PrivateName(n)),\\n ..left\\n }))),\\n op,\\n right,\\n })\\n .fold_children_with(self);\\n }\\n ExprOrSuper::Expr(ref obj) => obj.clone(),\\n };\\n\\n let is_static = self.statics.contains(&n.id.sym);\\n let ident = Ident::new(\\n format!(\"_{}\", n.id.sym).into(),\\n n.id.span.apply_mark(self.mark),\\n );\\n\\n let var = alias_ident_for(&obj, \"_ref\");\\n\\n let this = if match *obj {\\n Expr::This(..) => true,\\n _ => false,\\n } {\\n ThisExpr { span: DUMMY_SP }.as_arg()\\n } else if op == op!(\"=\") {\\n obj.as_arg()\\n } else {\\n self.vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(var.clone().into()),\\n init: None,\\n definite: false,\\n });\\n AssignExpr {\\n span: obj.span(),\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(var.clone().into()))),\\n op: op!(\"=\"),\\n right: obj,\\n }\\n .as_arg()\\n };\\n\\n let value = if op == op!(\"=\") {\\n right.as_arg()\\n } else {\\n let left = Box::new(self.fold_private_get(left, Some(var)).0);\\n\\n BinExpr {\\n span: DUMMY_SP,\\n left,\\n op: match op {\\n op!(\"=\") => unreachable!(),\\n\\n op!(\"+=\") => op!(bin, \"+\"),\\n op!(\"-=\") => op!(bin, \"-\"),\\n op!(\"*=\") => op!(\"*\"),\\n op!(\"/=\") => op!(\"/\"),\\n op!(\"%=\") => op!(\"%\"),\\n op!(\"<<=\") => op!(\"<<\"),\\n op!(\">>=\") => op!(\">>\"),\\n op!(\">>>=\") => op!(\">>>\"),\\n op!(\"|=\") => op!(\"|\"),\\n op!(\"&=\") => op!(\"&\"),\\n op!(\"^=\") => op!(\"^\"),\\n op!(\"**=\") => op!(\"**\"),\\n op!(\"&&=\") => op!(\"&&\"),\\n op!(\"||=\") => op!(\"||\"),\\n op!(\"??=\") => op!(\"??\"),\\n },\\n right,\\n }\\n .as_arg()\\n };\\n\\n if is_static {\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: helper!(\\n class_static_private_field_spec_set,\\n \"classStaticPrivateFieldSpecSet\"\\n ),\\n args: vec![\\n this,\\n self.class_name.clone().as_arg(),\\n ident.as_arg(),\\n value,\\n ],\\n\\n type_args: Default::default(),\\n })\\n } else {\\n let set = helper!(class_private_field_set, \"classPrivateFieldSet\");\\n\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: set,\\n args: vec![this, ident.as_arg(), value],\\n\\n type_args: Default::default(),\\n })\\n }\\n }\\n\\n Expr::Assign(AssignExpr {\\n span,\\n left: PatOrExpr::Pat(left),\\n op,\\n right,\\n }) => {\\n let right = right.fold_with(self);\\n\\n self.in_assign_pat = true;\\n let left = left.fold_with(self);\\n self.in_assign_pat = false;\\n\\n Expr::Assign(AssignExpr {\\n span,\\n left: PatOrExpr::Pat(left),\\n op,\\n right,\\n })\\n }\\n\\n // Actuall this is a call and we should bind `this`.\\n Expr::TaggedTpl(TaggedTpl {\\n span,\\n tag,\\n tpl,\\n type_params,\\n }) if tag.is_member() => {\\n let tag = tag.member().unwrap().fold_with(self);\\n let tpl = tpl.fold_with(self);\\n\\n let (e, this) = self.fold_private_get(tag, None);\\n\\n if let Some(this) = this {\\n Expr::TaggedTpl(TaggedTpl {\\n span,\\n tag: Box::new(Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: e.make_member(quote_ident!(\"bind\")).as_callee(),\\n args: vec![this.as_arg()],\\n type_args: Default::default(),\\n })),\\n tpl,\\n type_params,\\n })\\n } else {\\n Expr::TaggedTpl(TaggedTpl {\\n span,\\n tag: Box::new(e),\\n tpl,\\n type_params,\\n })\\n }\\n }\\n\\n Expr::Call(CallExpr {\\n span,\\n callee: ExprOrSuper::Expr(callee),\\n args,\\n type_args,\\n }) if callee.is_member() => {\\n let callee = callee.member().unwrap().fold_with(self);\\n let args = args.fold_with(self);\\n\\n let (e, this) = self.fold_private_get(callee, None);\\n\\n if let Some(this) = this {\\n Expr::Call(CallExpr {\\n span,\\n callee: e.make_member(quote_ident!(\"call\")).as_callee(),\\n args: iter::once(this.as_arg()).chain(args).collect(),\\n type_args,\\n })\\n } else {\\n Expr::Call(CallExpr {\\n span,\\n callee: ExprOrSuper::Expr(Box::new(e)),\\n args,\\n type_args,\\n })\\n }\\n }\\n Expr::Member(e) => {\\n let e = e.fold_with(self);\\n self.fold_private_get(e, None).0\\n }\\n _ => e.fold_children_with(self),\\n }\\n }\\n\\n fn fold_member_expr(&mut self, mut e: MemberExpr) -> MemberExpr {\\n e.obj = e.obj.fold_with(self);\\n if e.computed {\\n e.prop = e.prop.fold_with(self);\\n }\\n e\\n }\\n\\n fn fold_pat(&mut self, p: Pat) -> Pat {\\n if let Pat::Expr(expr) = &p {\\n if let Expr::Member(me) = &**expr {\\n if let Expr::PrivateName(..) = &*me.prop {\\n self.in_assign_pat = true;\\n let p = p.fold_children_with(self);\\n self.in_assign_pat = false;\\n\\n return p;\\n }\\n }\\n }\\n\\n self.in_assign_pat = false;\\n\\n p.fold_children_with(self)\\n }\\n}\\n\\nimpl<\\'a> FieldAccessFolder<\\'a> {\\n /// Returns `(expr, thisObject)`\\n ///\\n /// - `obj_alias`: If alias is already declared, this method will use\\n /// `obj_alias` instead of declaring a new one.\\n fn fold_private_get(\\n &mut self,\\n e: MemberExpr,\\n obj_alias: Option,\\n ) -> (Expr, Option) {\\n let is_alias_initialized = obj_alias.is_some();\\n\\n let n = match *e.prop {\\n Expr::PrivateName(n) => n,\\n _ => return (Expr::Member(e), None),\\n };\\n\\n let obj = match e.obj {\\n ExprOrSuper::Super(..) => {\\n return (\\n Expr::Member(MemberExpr {\\n prop: Box::new(Expr::PrivateName(n)),\\n ..e\\n }),\\n None,\\n );\\n }\\n ExprOrSuper::Expr(obj) => obj,\\n };\\n\\n let is_method = self.private_methods.contains(&n.id.sym);\\n let is_static = self.statics.contains(&n.id.sym);\\n let method_name = Ident::new(\\n n.id.sym.clone(),\\n n.id.span\\n .with_ctxt(SyntaxContext::empty())\\n .apply_mark(self.method_mark),\\n );\\n let ident = Ident::new(\\n format!(\"_{}\", n.id.sym).into(),\\n n.id.span.apply_mark(self.mark),\\n );\\n\\n if is_static {\\n if is_method {\\n let h = helper!(\\n class_static_private_method_get,\\n \"classStaticPrivateMethodGet\"\\n );\\n\\n return (\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: h,\\n args: vec![\\n obj.as_arg(),\\n self.class_name.clone().as_arg(),\\n method_name.as_arg(),\\n ],\\n type_args: Default::default(),\\n }),\\n Some(Expr::Ident(self.class_name.clone())),\\n );\\n }\\n\\n let get = helper!(\\n class_static_private_field_spec_get,\\n \"classStaticPrivateFieldSpecGet\"\\n );\\n\\n (\\n Expr::Call(CallExpr {\\n span: DUMMY_SP,\\n callee: get,\\n args: vec![\\n obj.as_arg(),\\n self.class_name.clone().as_arg(),\\n ident.as_arg(),\\n ],\\n type_args: Default::default(),\\n }),\\n Some(Expr::Ident(self.class_name.clone())),\\n )\\n } else {\\n if self.in_assign_pat {\\n let set = helper!(\\n class_private_field_destructure,\\n \"classPrivateFieldDestructureSet\"\\n );\\n\\n return match *obj {\\n Expr::This(this) => (\\n CallExpr {\\n span: DUMMY_SP,\\n callee: set,\\n args: vec![this.as_arg(), ident.as_arg()],\\n\\n type_args: Default::default(),\\n }\\n .make_member(quote_ident!(\"value\"))\\n .into(),\\n Some(Expr::This(this)),\\n ),\\n _ => unimplemented!(\"destructuring set for object except this\"),\\n };\\n }\\n\\n if is_method {\\n let h = helper!(class_private_method_get, \"classPrivateMethodGet\");\\n\\n return (\\n CallExpr {\\n span: DUMMY_SP,\\n callee: h,\\n args: vec![obj.as_arg(), ident.as_arg(), method_name.as_arg()],\\n type_args: Default::default(),\\n }\\n .into(),\\n Some(Expr::This(ThisExpr { span: DUMMY_SP })),\\n );\\n }\\n\\n let get = helper!(class_private_field_get, \"classPrivateFieldGet\");\\n\\n match *obj {\\n Expr::This(this) => (\\n CallExpr {\\n span: DUMMY_SP,\\n callee: get,\\n args: vec![this.as_arg(), ident.as_arg()],\\n\\n type_args: Default::default(),\\n }\\n .into(),\\n Some(Expr::This(this)),\\n ),\\n _ => {\\n let mut aliased = false;\\n let var = obj_alias.unwrap_or_else(|| {\\n let (var, a) = alias_if_required(&obj, \"_ref\");\\n if a {\\n aliased = true;\\n self.vars.push(VarDeclarator {\\n span: DUMMY_SP,\\n name: Pat::Ident(var.clone().into()),\\n init: None,\\n definite: false,\\n });\\n }\\n var\\n });\\n\\n (\\n CallExpr {\\n span: DUMMY_SP,\\n callee: get,\\n args: vec![\\n if is_alias_initialized {\\n var.clone().as_arg()\\n } else {\\n if aliased {\\n AssignExpr {\\n span: DUMMY_SP,\\n left: PatOrExpr::Pat(Box::new(Pat::Ident(\\n var.clone().into(),\\n ))),\\n op: op!(\"=\"),\\n right: obj,\\n }\\n .as_arg()\\n } else {\\n var.clone().as_arg()\\n }\\n },\\n ident.as_arg(),\\n ],\\n\\n type_args: Default::default(),\\n }\\n .into(),\\n Some(Expr::Ident(var)),\\n )\\n }\\n }\\n }\\n }\\n}\\n',\n", + " 'content_id': '263ae6a59ad85d675965fcc32d73183c385a12e5',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 98,\n", + " 'path': '/ecmascript/transforms/compat/src/es2020/class_properties/private_field.rs',\n", + " 'size': 24949,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4923616328575006,\n", + " 'avg_line_length': 26.923076923076923,\n", + " 'blob_id': '316370ef3aba2fe1ba58efb613feb1a50ac4e99a',\n", + " 'content': 'use rustc_hash::FxHashSet;\\nuse std::borrow::Cow;\\nuse swc_common::{pass::CompilerPass, EqIgnoreSpan, Mark, SyntaxContext};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{noop_visit_mut_type, noop_visit_type, Visit, VisitMut, VisitMutWith};\\n\\npub fn globals_defs(defs: Vec<(Box, Box)>, top_level_mark: Mark) -> impl VisitMut {\\n GlobalDefs {\\n defs,\\n top_level_ctxt: SyntaxContext::empty().apply_mark(top_level_mark),\\n ..Default::default()\\n }\\n}\\n\\n#[derive(Default)]\\nstruct GlobalDefs {\\n defs: Vec<(Box, Box)>,\\n /// If syntax context of a identifier reference is not top-level, it means\\n /// the reference points a binding (var / fn / class or whatever).\\n top_level_ctxt: SyntaxContext,\\n /// If a varaible is registered in this variable, it\\'s not a global\\n /// constant.\\n ///\\n /// Non-top level bindings are filtered using `top_level_mark`.\\n top_level_bindings: FxHashSet,\\n in_lhs_of_assign: bool,\\n}\\n\\nimpl CompilerPass for GlobalDefs {\\n fn name() -> Cow<\\'static, str> {\\n Cow::Borrowed(\"global-defs\")\\n }\\n}\\n\\n/// Finds top-level bindings.\\nimpl Visit for GlobalDefs {\\n noop_visit_type!();\\n}\\n\\n/// We use [VisitMut] instead of [swc_ecma_visit::Fold] because it\\'s faster.\\nimpl VisitMut for GlobalDefs {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr) {\\n let old = self.in_lhs_of_assign;\\n self.in_lhs_of_assign = true;\\n n.left.visit_mut_with(self);\\n self.in_lhs_of_assign = false;\\n n.right.visit_mut_with(self);\\n self.in_lhs_of_assign = old;\\n }\\n\\n fn visit_mut_expr(&mut self, n: &mut Expr) {\\n if self.in_lhs_of_assign {\\n return;\\n }\\n\\n match n {\\n Expr::Ident(i) => {\\n if i.span.ctxt != self.top_level_ctxt\\n || self.top_level_bindings.contains(&i.to_id())\\n {\\n return;\\n }\\n }\\n Expr::Member(MemberExpr {\\n obj: ExprOrSuper::Expr(obj),\\n ..\\n }) => match &**obj {\\n Expr::Ident(i) => {\\n if i.span.ctxt != self.top_level_ctxt\\n || self.top_level_bindings.contains(&i.to_id())\\n {\\n return;\\n }\\n }\\n _ => {}\\n },\\n _ => {}\\n }\\n\\n if let Some((_, new)) = self.defs.iter().find(|(pred, _)| should_replace(&pred, &n)) {\\n *n = *new.clone();\\n return;\\n }\\n\\n n.visit_mut_children_with(self);\\n }\\n\\n #[inline]\\n fn visit_mut_update_expr(&mut self, e: &mut UpdateExpr) {\\n match &mut *e.arg {\\n Expr::Ident(..) => {}\\n\\n Expr::Member(MemberExpr {\\n computed: false, ..\\n }) => {\\n // TODO: Check for `obj`\\n }\\n\\n _ => {\\n e.arg.visit_mut_with(self);\\n }\\n }\\n }\\n}\\n\\n/// This is used to detect optional chaining expressions like `a?.b.c` without\\n/// allocation.\\nfn should_replace(pred: &Expr, node: &Expr) -> bool {\\n if pred.eq_ignore_span(node) {\\n return true;\\n }\\n\\n match (pred, node) {\\n (pred, Expr::OptChain(node)) => {\\n if should_replace(pred, &node.expr) {\\n return true;\\n }\\n }\\n\\n (Expr::Member(pred), Expr::Member(node)) => {\\n if pred.computed || node.computed {\\n return false;\\n }\\n\\n if !pred.prop.eq_ignore_span(&node.prop) {\\n return false;\\n }\\n\\n match (&pred.obj, &node.obj) {\\n (ExprOrSuper::Expr(pred_obj), ExprOrSuper::Expr(node_obj)) => {\\n return should_replace(pred_obj, node_obj)\\n }\\n _ => {}\\n }\\n }\\n _ => {}\\n }\\n\\n false\\n}\\n',\n", + " 'content_id': '4307a3e8c31e51e288f39b3d6dfc1c04d3eebcbc',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 95,\n", + " 'path': '/ecmascript/minifier/src/pass/global_defs.rs',\n", + " 'size': 3993,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6260162601626016,\n", + " 'avg_line_length': 29.75,\n", + " 'blob_id': '0a656e8faabc4276983e16af19bc2d84dca9f550',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"JsDoc parser writen in rust\"\\ndocumentation = \"https://rustdoc.swc.rs/jsdoc/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"jsdoc\"\\nversion = \"0.41.0\"\\n\\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\\n\\n[dependencies]\\nnom = \"5.1.2\"\\nserde = {version = \"1\", features = [\"derive\"]}\\nswc_atoms = {version = \"0.2\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\n\\n[dev-dependencies]\\nanyhow = \"1\"\\ndashmap = \"4.0.2\"\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../parser\"}\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\nwalkdir = \"2\"\\n',\n", + " 'content_id': 'ece43ff07ecaf3059e4ed4a30070d1dc003c5567',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 96,\n", + " 'path': '/ecmascript/jsdoc/Cargo.toml',\n", + " 'size': 738,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5152295802394302,\n", + " 'avg_line_length': 23.44074074074074,\n", + " 'blob_id': 'ac4442ec02c593cae9683c6119af72b5919d1f89',\n", + " 'content': 'name: Cargo\\n\\non: [push, pull_request]\\n#on:\\n# push:\\n# # Ignore commits created by bors\\n# branches-ignore:\\n# - \\'staging\\'\\n# - \\'trying\\'\\n# pull_request:\\n# branches-ignore:\\n# - \\'staging\\'\\n# - \\'trying\\'\\n\\nenv:\\n CI: 1\\n CARGO_INCREMENTAL: 0\\n RUST_LOG: \"debug\"\\n\\njobs:\\n check-license:\\n name: Check license\\n runs-on: ubuntu-latest\\n steps:\\n - uses: actions/checkout@v2\\n\\n - name: Install Rust\\n uses: actions-rs/toolchain@v1\\n with:\\n profile: minimal\\n\\n - name: Install required tools\\n run: |\\n cargo install cargo-deny\\n\\n - name: Check licenses\\n run: |\\n cargo deny check\\n\\n fmt:\\n name: fmt\\n runs-on: ubuntu-latest\\n env:\\n RUST_LOG: \"0\"\\n steps:\\n - uses: actions/checkout@v2\\n\\n # We explicitly do this to cache properly.\\n - name: Install Rust\\n uses: actions-rs/toolchain@v1\\n with:\\n profile: minimal\\n components: rustfmt\\n\\n - name: Run cargo fmt\\n run: cargo fmt --all -- --check\\n\\n check:\\n name: Check\\n runs-on: ${{ matrix.os }}\\n strategy:\\n fail-fast: false\\n matrix:\\n os:\\n - ubuntu-latest\\n - macos-10.15\\n - windows-latest\\n steps:\\n - uses: actions/checkout@v2\\n\\n # We explicitly do this to cache properly.\\n - name: Install Rust\\n uses: actions-rs/toolchain@v1\\n with:\\n profile: minimal\\n\\n - name: Cache\\n uses: actions/cache@v2\\n with:\\n path: |\\n ~/.cargo/\\n target\\n Cargo.lock\\n key: ${{ runner.os }}-cargo-v4\\n # Ensure that all components are compilable.\\n - name: Run cargo check for all targets\\n run: cargo check --color always --all --all-targets\\n test:\\n name: Test\\n needs:\\n - check\\n runs-on: ${{ matrix.os }}\\n strategy:\\n fail-fast: false\\n matrix:\\n os:\\n - ubuntu-latest\\n # - macos-10.15\\n - windows-latest\\n crate:\\n - ast_node\\n - enum_kind\\n - from_variant\\n - jsdoc\\n - node\\n - string_enum\\n - swc\\n - swc_atoms\\n - swc_babel_ast\\n - swc_babel_compat\\n - swc_babel_visit\\n - swc_bundler\\n - swc_common\\n - swc_css\\n - swc_css_ast\\n - swc_css_codegen\\n - swc_css_parser\\n - swc_css_utils\\n - swc_css_visit\\n - swc_ecma_ast\\n - swc_ecma_codegen\\n - swc_ecma_codegen_macros\\n - swc_ecma_dep_graph\\n - swc_ecma_ext_transforms\\n - swc_ecma_loader\\n - swc_ecma_minifier\\n - swc_ecma_parser\\n - swc_ecma_preset_env\\n - swc_ecma_transforms\\n - swc_ecma_transforms_base\\n - swc_ecma_transforms_classes\\n - swc_ecma_transforms_compat\\n - swc_ecma_transforms_macros\\n - swc_ecma_transforms_module\\n - swc_ecma_transforms_optimization\\n - swc_ecma_transforms_proposal\\n - swc_ecma_transforms_react\\n - swc_ecma_transforms_testing\\n - swc_ecma_transforms_typescript\\n - swc_ecma_utils\\n - swc_ecma_visit\\n - swc_ecmascript\\n - swc_eq_ignore_macros\\n - swc_macros_common\\n - swc_node_base\\n - swc_node_bundler\\n - swc_plugin\\n - swc_plugin_runner\\n - swc_plugin_testing\\n - swc_stylis\\n - swc_visit\\n - swc_visit_macros\\n - testing\\n - testing_macros\\n - wasm\\n exclude:\\n - os: windows-latest\\n crate: swc_node_bundler\\n\\n steps:\\n - name: Handle line endings\\n shell: bash\\n if: runner.os == \\'Windows\\'\\n run: |\\n git config --system core.autocrlf false\\n git config --system core.eol lf\\n\\n - uses: actions/checkout@v2\\n\\n # Source map format\\n - uses: actions/setup-node@v2\\n with:\\n node-version: \"16\"\\n\\n # We explicitly do this to cache properly.\\n - name: Install Rust\\n uses: actions-rs/toolchain@v1\\n with:\\n profile: minimal\\n\\n - uses: actions/setup-node@v2\\n with:\\n node-version: 16\\n\\n - uses: denoland/setup-deno@v1\\n with:\\n deno-version: v1.x\\n\\n - name: Checkout submodules\\n shell: bash\\n run: |\\n auth_header=\"$(git config --local --get http.https://github.com/.extraheader)\"\\n git submodule sync --recursive\\n git -c \"http.extraheader=$auth_header\" -c protocol.version=2 submodule update --init --force --recursive --depth=1\\n\\n - name: Install node dependencies\\n shell: bash\\n run: |\\n # This does not have any effect on windows.\\n npm config set prefix $HOME/npm\\n yarn\\n (cd ecmascript/transforms && yarn)\\n npm i -g jest\\n echo $HOME\\n echo $HOME/npm/bin >> $GITHUB_PATH\\n\\n - name: Configure path (windows)\\n shell: bash\\n if: runner.os == \\'Windows\\'\\n run: |\\n echo \\'C:\\\\\\\\npm\\\\\\\\prefix\\' >> $GITHUB_PATH\\n\\n - name: Verify dependencies\\n shell: bash\\n run: |\\n jest -v\\n\\n - name: Cache\\n uses: actions/cache@v2\\n with:\\n path: |\\n ~/.cargo/\\n target\\n Cargo.lock\\n key: ${{ runner.os }}-cargo-v4\\n\\n - name: Run cargo test\\n run: |\\n jest -v\\n cargo test --color always -p ${{ matrix.crate }}\\n\\n - name: Run cargo test (concurrent)\\n if: matrix.crate == \\'swc_bundler\\'\\n run: |\\n cd bundler\\n cargo test --color always -p ${{ matrix.crate }} --all-features\\n\\n deploy-docs:\\n name: Docs\\n runs-on: ubuntu-latest\\n # if: github.ref == \\'refs/heads/master\\'\\n # needs:\\n # - test\\n steps:\\n - uses: actions/checkout@v2\\n\\n - name: Install Rust\\n uses: actions-rs/toolchain@v1\\n with:\\n profile: minimal\\n\\n - name: Create rustdoc\\n run: cargo doc --all\\n\\n - name: Create CNAME\\n run: |\\n echo \\'rustdoc.swc.rs\\' > target/doc/CNAME\\n\\n - name: Deploy\\n if: github.ref == \\'refs/heads/master\\'\\n uses: JamesIves/github-pages-deploy-action@4.1.0\\n with:\\n token: ${{ secrets.GH_TOKEN }}\\n branch: gh-pages\\n folder: target/doc\\n clean: true\\n git-config-email: github-bot@swc.rs\\n repository-name: swc-project/rustdoc\\n commit-message: \"Update\"\\n single-commit: true\\n',\n", + " 'content_id': '645fe2b9a3399a381e9b088079a86bb10bd4b8c2',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'yml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'YAML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 124,\n", + " 'path': '/.github/workflows/cargo.yml',\n", + " 'size': 6599,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.4716248711782893,\n", + " 'avg_line_length': 27.736426456071076,\n", + " 'blob_id': 'dd4f7612edd8b2a5e2060330dfc76fbae0ef1152',\n", + " 'content': 'use self::ops::{Operations, Operator};\\nuse crate::{\\n native::is_native_word,\\n scope::{IdentType, ScopeKind},\\n};\\nuse rustc_hash::{FxHashMap, FxHashSet};\\nuse smallvec::{smallvec, SmallVec};\\nuse std::{cell::RefCell, collections::HashMap};\\nuse swc_atoms::{js_word, JsWord};\\nuse swc_common::{chain, util::take::Take, SyntaxContext};\\nuse swc_ecma_ast::*;\\nuse swc_ecma_utils::{ident::IdentLike, Id};\\nuse swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};\\n\\nmod ops;\\n#[cfg(test)]\\nmod tests;\\n\\nconst LOG: bool = false;\\n\\n#[derive(Debug, Clone, Default)]\\npub struct Config {\\n /// If true, the `hygiene` pass will preserve class names.\\n pub keep_class_names: bool,\\n}\\n\\ntrait ToBoxedStr {\\n fn to_boxed_str(&self) -> Box;\\n}\\n\\nimpl ToBoxedStr for JsWord {\\n fn to_boxed_str(&self) -> Box {\\n (**self).to_owned().into_boxed_str()\\n }\\n}\\n\\nstruct Hygiene<\\'a> {\\n config: Config,\\n current: Scope<\\'a>,\\n ident_type: IdentType,\\n var_kind: Option,\\n}\\n\\ntype Contexts = SmallVec<[SyntaxContext; 32]>;\\n\\nimpl<\\'a> Hygiene<\\'a> {\\n /// Check `id` while exiting scope.\\n ///\\n /// We handle this while exiting a scope. See check_enqueued for details.\\n fn enqueue_check(&mut self, id: Id) {\\n if self.current.check_queue.contains(&id) {\\n return;\\n }\\n self.current.check_queue.push(id);\\n }\\n\\n fn add_decl(&mut self, ident: Ident) {\\n let ctxt = ident.span.ctxt();\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\\n \"({}) Declaring {}{:?} \",\\n self.current.depth(),\\n ident.sym,\\n ctxt\\n );\\n }\\n\\n let sym = self.current.change_symbol(ident.sym, ctxt);\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\tChanged symbol to {}{:?} \", sym, ctxt);\\n }\\n\\n {\\n let mut b = self.current.declared_symbols.borrow_mut();\\n let e = b.entry(sym.clone()).or_default();\\n if !e.contains(&ctxt) {\\n e.push(ctxt);\\n }\\n }\\n\\n {\\n let mut need_work = false;\\n let mut is_cur = true;\\n let mut cur = Some(&self.current);\\n\\n while let Some(c) = cur {\\n let mut used = c.used.borrow_mut();\\n let e = used.entry(sym.clone()).or_default();\\n\\n if !e.contains(&ctxt) {\\n e.push(ctxt);\\n }\\n\\n if e.len() <= 1 {\\n } else {\\n if is_cur {\\n need_work = true;\\n }\\n }\\n\\n // Preserve first one.\\n if e.len() == 1 && e[0] == ctxt {\\n } else {\\n if is_cur {\\n need_work = true;\\n }\\n }\\n\\n is_cur = false;\\n cur = c.parent;\\n }\\n\\n if !need_work {\\n return;\\n }\\n }\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"Renaming from decl\");\\n }\\n self.rename(sym, ctxt);\\n }\\n\\n fn add_used_ref(&mut self, ident: &Ident) {\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\\n \"({}) Ident ref: {}{:?}\",\\n self.current.depth(),\\n ident.sym,\\n ident.span.ctxt\\n );\\n }\\n\\n let ctxt = ident.span.ctxt();\\n\\n {\\n let mut decl_cnt = 0;\\n\\n let mut cur = Some(&self.current);\\n\\n while let Some(c) = cur {\\n let b = c.declared_symbols.borrow();\\n\\n if let Some(ctxts) = b.get(&ident.sym.clone()) {\\n decl_cnt += ctxts.len();\\n }\\n\\n cur = c.parent;\\n }\\n\\n if decl_cnt >= 2 {\\n self.enqueue_check(ident.to_id());\\n }\\n }\\n\\n {\\n let mut need_work = false;\\n\\n let mut is_cur = true;\\n let mut cur = Some(&self.current);\\n\\n while let Some(c) = cur {\\n let mut used = c.used.borrow_mut();\\n let e = used.entry(ident.sym.clone()).or_default();\\n\\n if !e.contains(&ctxt) {\\n e.push(ctxt);\\n }\\n\\n if e.len() <= 1 {\\n } else {\\n if is_cur {\\n need_work = true;\\n }\\n }\\n\\n if e.len() == 1 && e[0] == ctxt {\\n } else {\\n if is_cur {\\n need_work = true;\\n }\\n }\\n\\n is_cur = false;\\n cur = c.parent;\\n }\\n\\n if !need_work {\\n return;\\n }\\n }\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"Renaming from reference\");\\n }\\n\\n // We rename declaration instead of usage\\n let conflicts = self.current.conflicts(ident.sym.clone(), ctxt);\\n\\n if cfg!(debug_assertions) && LOG && !conflicts.is_empty() {\\n eprintln!(\"({}) Renaming from usage\", self.current.depth());\\n }\\n\\n for cx in conflicts {\\n self.rename(ident.sym.clone(), cx)\\n }\\n }\\n\\n fn rename(&mut self, sym: JsWord, ctxt: SyntaxContext) {\\n // symbol conflicts\\n let renamed = {\\n let mut i = 0;\\n loop {\\n i += 1;\\n let sym = format!(\"{}{}\", sym, i).into();\\n\\n if !self.current.is_declared(&sym) {\\n break sym;\\n }\\n }\\n };\\n\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\t{}{:?} -> {}\", sym, ctxt, renamed);\\n }\\n\\n let sym = self.current.change_symbol(sym, ctxt);\\n {\\n let scope = self.current.scope_of(&sym, ctxt, self.var_kind);\\n\\n // Update symbol list\\n let mut declared_symbols = scope.declared_symbols.borrow_mut();\\n\\n {\\n // This assertion was correct in old time, but bundler creates\\n // same variable with same name and same span\\n // hygiene, so this assertion is not valid anymore.\\n //\\n // I decided not to remove this code because I may modify the\\n // bundler to be correct in aspect of original span hygiene.\\n\\n // let is_not_renamed =\\n // !scope.ops.borrow().rename.contains_key(&(sym.clone(),\\n // ctxt));\\n\\n // debug_assert!(\\n // is_not_renamed,\\n // \"failed to rename {}{:?}: should not rename an ident\\n // multiple time\\\\n{:?}\", sym,\\n // ctxt,\\n // scope.ops.borrow(),\\n // );\\n }\\n\\n let old = declared_symbols.entry(sym.clone()).or_default();\\n old.retain(|c| *c != ctxt);\\n // debug_assert!(old.is_empty() || old.len() == 1);\\n\\n let new = declared_symbols\\n .entry(renamed.clone().into())\\n .or_insert_with(|| Vec::with_capacity(2));\\n new.push(ctxt);\\n debug_assert!(new.len() == 1);\\n\\n scope\\n .ops\\n .borrow_mut()\\n .rename\\n .insert((sym, ctxt), renamed.clone().into());\\n }\\n self.current.renamed.insert(renamed.into());\\n }\\n}\\n\\n/// See [hygiene_with_config] for doc. Creates a `hygiene` pass with default\\n/// value of [Config].\\npub fn hygiene() -> impl Fold + \\'static {\\n hygiene_with_config(Default::default())\\n}\\n\\n/// The pass actually modifies the identifiers in the way that different\\n/// identifier (with respect to span hygiene) becomes different identifier.\\n/// (e.g. `a1` for `a#6`, `a2` for `a#23`)\\npub fn hygiene_with_config(config: Config) -> impl \\'static + Fold + VisitMut {\\n chain!(\\n as_folder(Hygiene {\\n config,\\n current: Default::default(),\\n ident_type: IdentType::Ref,\\n var_kind: None,\\n }),\\n as_folder(MarkClearer)\\n )\\n}\\n\\n#[derive(Clone, Copy)]\\nstruct MarkClearer;\\nimpl VisitMut for MarkClearer {\\n noop_visit_mut_type!();\\n\\n fn visit_mut_ident(&mut self, ident: &mut Ident) {\\n ident.span.ctxt = SyntaxContext::empty();\\n }\\n}\\n\\nimpl<\\'a> Hygiene<\\'a> {\\n /// Move `check_queue` to `ops`.\\n ///\\n /// # Implementation notes\\n ////\\n /// This only handles variables declared in current scope.\\n /// You may think it\\'s possible to avoid adding an [Id] to `check_queue`\\n /// entirely, but it\\'s not possible because declarations can come after\\n /// usages.\\n fn check_enqueued(&mut self) {\\n if self.current.check_queue.is_empty() {\\n return;\\n }\\n\\n for (sym, ctxt) in self.current.check_queue.take() {\\n // Check if it\\'s in the current scope.\\n if let Some(decls) = self.current.declared_symbols.borrow().get(&sym) {\\n if !decls.contains(&ctxt) {\\n continue;\\n }\\n }\\n\\n {\\n // We check for all used identifiers in current scope.\\n // If `ctxt` is the only one, it\\'s fine.\\n // If other syntax context is used, we need to rename it.\\n\\n let mut other_ctxts = vec![];\\n\\n let used = self.current.used.borrow();\\n\\n if let Some(ctxts) = used.get(&sym) {\\n \\'add_loop: for &cx in ctxts {\\n if cx == ctxt {\\n continue;\\n }\\n\\n // Prevent duplicate\\n if other_ctxts.contains(&cx) {\\n continue;\\n }\\n\\n // If a declaration name is going to be renamed, it\\'s not a conflict.\\n let mut cur = Some(&self.current);\\n while let Some(c) = cur {\\n let ops = c.ops.borrow();\\n\\n if ops.rename.contains_key(&(sym.clone(), cx)) {\\n continue \\'add_loop;\\n }\\n cur = c.parent;\\n }\\n\\n other_ctxts.push(cx);\\n }\\n }\\n\\n if other_ctxts.is_empty() {\\n continue;\\n }\\n }\\n\\n self.rename(sym, ctxt);\\n }\\n }\\n\\n fn apply_ops(&mut self, node: &mut N)\\n where\\n for<\\'o> N: VisitMutWith>,\\n {\\n self.check_enqueued();\\n\\n let ops = self.current.ops.borrow();\\n\\n let ids_to_remove = self.current.declared_symbols.borrow();\\n\\n {\\n let mut cur = Some(&self.current);\\n while let Some(c) = cur {\\n let mut used = c.used.borrow_mut();\\n\\n for (sym, ctxts) in ids_to_remove.iter() {\\n let e = used.entry(sym.clone()).or_default();\\n\\n for ctxt in ctxts.iter().copied() {\\n if let Some(pos) = e.iter().position(|&c| c == ctxt) {\\n e.remove(pos);\\n }\\n }\\n }\\n\\n for ((sym, ctxt), _) in &ops.rename {\\n let e = used.entry(sym.clone()).or_default();\\n\\n if let Some(pos) = e.iter().position(|c| *c == *ctxt) {\\n e.remove(pos);\\n }\\n }\\n\\n cur = c.parent;\\n }\\n }\\n\\n if ops.rename.is_empty() {\\n return;\\n }\\n\\n node.visit_mut_with(&mut Operator(&ops))\\n }\\n\\n fn keep_class_name(&mut self, ident: &mut Ident, class: &mut Class) -> Option {\\n if !self.config.keep_class_names {\\n return None;\\n }\\n\\n let mut orig_name = ident.clone();\\n orig_name.span.ctxt = SyntaxContext::empty();\\n\\n {\\n // Remove span hygiene of the class.\\n let mut rename = HashMap::default();\\n\\n rename.insert(ident.to_id(), orig_name.sym.clone());\\n\\n let ops = Operations { rename };\\n let mut operator = Operator(&ops);\\n\\n class.visit_mut_with(&mut operator);\\n }\\n\\n {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n ident.visit_mut_with(self);\\n self.ident_type = old;\\n }\\n class.visit_mut_with(self);\\n\\n let class_expr = ClassExpr {\\n ident: Some(orig_name),\\n class: class.take(),\\n };\\n\\n Some(class_expr)\\n }\\n}\\n\\nimpl<\\'a> Hygiene<\\'a> {\\n fn visit_mut_fn(&mut self, ident: &mut Option, node: &mut Function, is_decl: bool) {\\n if is_decl {\\n match ident.clone() {\\n Some(ident) => {\\n self.add_decl(ident.clone());\\n }\\n _ => {}\\n }\\n }\\n\\n let mut folder = Hygiene {\\n config: self.config.clone(),\\n current: Scope::new(ScopeKind::Fn, Some(&self.current)),\\n ident_type: IdentType::Ref,\\n var_kind: None,\\n };\\n\\n if !is_decl {\\n match ident {\\n Some(ident) => {\\n folder.add_decl(ident.clone());\\n }\\n _ => {}\\n }\\n }\\n\\n folder.ident_type = IdentType::Ref;\\n node.decorators.visit_mut_with(&mut folder);\\n\\n folder.ident_type = IdentType::Binding;\\n node.params.visit_mut_with(&mut folder);\\n\\n folder.ident_type = IdentType::Ref;\\n node.body\\n .as_mut()\\n .map(|stmt| stmt.visit_mut_children_with(&mut folder));\\n\\n folder.apply_ops(ident);\\n folder.apply_ops(node);\\n }\\n}\\n\\n#[derive(Debug)]\\nstruct Scope<\\'a> {\\n /// Parent scope of this scope\\n pub parent: Option<&\\'a Scope<\\'a>>,\\n\\n /// Kind of the scope.\\n pub kind: ScopeKind,\\n\\n pub used: RefCell>>,\\n\\n /// All references declared in this scope\\n pub declared_symbols: RefCell>>,\\n\\n pub(crate) ops: RefCell,\\n pub renamed: FxHashSet,\\n\\n check_queue: Vec,\\n}\\n\\nimpl<\\'a> Default for Scope<\\'a> {\\n fn default() -> Self {\\n Scope::new(ScopeKind::Fn, None)\\n }\\n}\\n\\nimpl<\\'a> Scope<\\'a> {\\n fn depth(&self) -> usize {\\n match self.parent {\\n Some(parent) => parent.depth() + 1,\\n None => 0,\\n }\\n }\\n\\n pub fn new(kind: ScopeKind, parent: Option<&\\'a Scope<\\'a>>) -> Self {\\n Scope {\\n parent,\\n kind,\\n declared_symbols: Default::default(),\\n // children: Default::default(),\\n ops: Default::default(),\\n renamed: Default::default(),\\n used: Default::default(),\\n check_queue: Default::default(),\\n }\\n }\\n\\n fn scope_of(\\n &self,\\n sym: &JsWord,\\n ctxt: SyntaxContext,\\n var_kind: Option,\\n ) -> &\\'a Scope<\\'_> {\\n // In case of `var` declarations, we should use function scope instead of\\n // current scope. This is to handle code like\\n //\\n // function foo() {\\n // if (a) {\\n // var b;\\n // }\\n // if (c) {\\n // b = foo()\\n // }\\n // }\\n //\\n match var_kind {\\n Some(VarDeclKind::Var) => {\\n // `var`s are function-scoped.\\n if self.kind == ScopeKind::Fn {\\n if let Some(prev) = self.declared_symbols.borrow().get(sym) {\\n if prev.contains(&ctxt) {\\n return self;\\n }\\n }\\n }\\n }\\n _ => {\\n if let Some(prev) = self.declared_symbols.borrow().get(sym) {\\n if prev.contains(&ctxt) {\\n return self;\\n }\\n }\\n }\\n }\\n\\n match self.parent {\\n Some(ref parent) => parent.scope_of(sym, ctxt, var_kind),\\n _ => self,\\n }\\n }\\n\\n /// Returns all **conflicting** contexts.\\n ///\\n /// It other words, all `SyntaxContext`s with same `sym` will be returned,\\n /// even when defined on parent scope.\\n\\n fn conflicts(&mut self, sym: JsWord, ctxt: SyntaxContext) -> Contexts {\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"Finding conflicts for {}{:?} \", sym, ctxt);\\n }\\n\\n let sym = self.change_symbol(sym, ctxt);\\n\\n let mut ctxts = smallvec![];\\n {\\n if let Some(cxs) = self.declared_symbols.get_mut().get(&sym) {\\n if cxs.len() != 1 || cxs[0] != ctxt {\\n ctxts.extend_from_slice(&cxs);\\n }\\n }\\n }\\n\\n let mut cur = self.parent;\\n\\n while let Some(scope) = cur {\\n if let Some(cxs) = scope.declared_symbols.borrow().get(&sym) {\\n if cxs.len() != 1 || cxs[0] != ctxt {\\n ctxts.extend_from_slice(&cxs);\\n }\\n }\\n\\n cur = scope.parent;\\n }\\n\\n ctxts.retain(|c| *c != ctxt);\\n ctxts.dedup();\\n\\n ctxts\\n }\\n\\n fn change_symbol(&self, mut sym: JsWord, ctxt: SyntaxContext) -> JsWord {\\n let mut cur = Some(self);\\n\\n while let Some(scope) = cur {\\n if let Some(to) = scope.ops.borrow().rename.get(&(sym.clone(), ctxt)) {\\n if cfg!(debug_assertions) && LOG {\\n eprintln!(\"\\\\tChanging symbol: {}{:?} -> {}\", sym, ctxt, to);\\n }\\n sym = to.clone()\\n }\\n\\n cur = scope.parent;\\n }\\n\\n sym\\n }\\n\\n fn is_declared(&self, sym: &JsWord) -> bool {\\n if self.declared_symbols.borrow().contains_key(sym) {\\n return true;\\n }\\n for (_, to) in &self.ops.borrow().rename {\\n if to == sym {\\n return true;\\n }\\n }\\n match self.parent {\\n Some(parent) => parent.is_declared(sym),\\n _ => false,\\n }\\n }\\n}\\n\\nmacro_rules! track_ident_mut {\\n () => {\\n fn visit_mut_export_specifier(&mut self, s: &mut ExportSpecifier) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Ref;\\n s.visit_mut_children_with(self);\\n self.ident_type = old;\\n }\\n\\n fn visit_mut_import_specifier(&mut self, s: &mut ImportSpecifier) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n\\n match s {\\n ImportSpecifier::Named(ImportNamedSpecifier { imported: None, .. })\\n | ImportSpecifier::Namespace(..)\\n | ImportSpecifier::Default(..) => s.visit_mut_children_with(self),\\n ImportSpecifier::Named(s) => s.local.visit_mut_with(self),\\n };\\n\\n self.ident_type = old;\\n }\\n\\n fn visit_mut_getter_prop(&mut self, f: &mut GetterProp) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Ref;\\n f.key.visit_mut_with(self);\\n self.ident_type = old;\\n\\n f.type_ann.visit_mut_with(self);\\n\\n f.body.visit_mut_with(self);\\n }\\n\\n // impl<\\'a> Fold for $T<\\'a> {\\n // fn fold(&mut self, f: GetterProp) -> GetterProp {\\n // let body = f.body.visit_mut_with(self);\\n\\n // GetterProp { body, ..c }\\n // }\\n // }\\n\\n fn visit_mut_labeled_stmt(&mut self, s: &mut LabeledStmt) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Label;\\n s.label.visit_mut_with(self);\\n self.ident_type = old;\\n\\n s.body.visit_mut_with(self);\\n }\\n\\n fn visit_mut_break_stmt(&mut self, s: &mut BreakStmt) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Label;\\n s.label.visit_mut_with(self);\\n self.ident_type = old;\\n }\\n\\n fn visit_mut_continue_stmt(&mut self, s: &mut ContinueStmt) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Label;\\n s.label.visit_mut_with(self);\\n self.ident_type = old;\\n }\\n\\n fn visit_mut_key_value_pat_prop(&mut self, n: &mut KeyValuePatProp) {\\n n.key.visit_mut_with(self);\\n n.value.visit_mut_with(self);\\n }\\n\\n fn visit_mut_class(&mut self, c: &mut Class) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Ref;\\n c.decorators.visit_mut_with(self);\\n\\n self.ident_type = IdentType::Ref;\\n c.super_class.visit_mut_with(self);\\n\\n self.ident_type = IdentType::Binding;\\n c.type_params.visit_mut_with(self);\\n\\n self.ident_type = IdentType::Ref;\\n c.super_type_params.visit_mut_with(self);\\n\\n self.ident_type = IdentType::Ref;\\n c.implements.visit_mut_with(self);\\n self.ident_type = old;\\n\\n c.body.visit_mut_with(self);\\n }\\n\\n fn visit_mut_prop_name(&mut self, n: &mut PropName) {\\n match n {\\n PropName::Computed(c) => {\\n c.visit_mut_with(self);\\n }\\n _ => {}\\n }\\n }\\n };\\n}\\n\\nimpl<\\'a> VisitMut for Hygiene<\\'a> {\\n noop_visit_mut_type!();\\n\\n track_ident_mut!();\\n\\n fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {\\n let mut folder = Hygiene {\\n config: self.config.clone(),\\n current: Scope::new(ScopeKind::Fn, Some(&self.current)),\\n ident_type: IdentType::Ref,\\n var_kind: None,\\n };\\n\\n folder.ident_type = IdentType::Binding;\\n node.params.visit_mut_with(&mut folder);\\n\\n folder.ident_type = IdentType::Ref;\\n node.body.visit_mut_with(&mut folder);\\n\\n folder.apply_ops(node)\\n }\\n\\n fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {\\n let mut folder = Hygiene {\\n config: self.config.clone(),\\n current: Scope::new(ScopeKind::Block, Some(&self.current)),\\n ident_type: IdentType::Ref,\\n var_kind: None,\\n };\\n node.visit_mut_children_with(&mut folder);\\n\\n folder.apply_ops(node)\\n }\\n\\n fn visit_mut_catch_clause(&mut self, c: &mut CatchClause) {\\n self.ident_type = IdentType::Binding;\\n c.param.visit_mut_with(self);\\n\\n let mut folder = Hygiene {\\n config: self.config.clone(),\\n current: Scope::new(ScopeKind::Fn, Some(&self.current)),\\n ident_type: IdentType::Ref,\\n var_kind: None,\\n };\\n folder.ident_type = IdentType::Ref;\\n\\n c.body.visit_mut_with(&mut folder);\\n\\n folder.apply_ops(c);\\n }\\n\\n fn visit_mut_class_decl(&mut self, n: &mut ClassDecl) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n n.ident.visit_mut_with(self);\\n self.ident_type = old;\\n\\n n.class.visit_mut_with(self);\\n }\\n\\n fn visit_mut_class_expr(&mut self, n: &mut ClassExpr) {\\n if let Some(ident) = &mut n.ident {\\n if let Some(expr) = self.keep_class_name(ident, &mut n.class) {\\n *n = expr;\\n return;\\n }\\n }\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n n.ident.visit_mut_with(self);\\n self.ident_type = old;\\n\\n n.class.visit_mut_with(self);\\n }\\n\\n fn visit_mut_class_method(&mut self, n: &mut ClassMethod) {\\n n.function.decorators.visit_mut_with(self);\\n\\n let mut folder = Hygiene {\\n config: self.config.clone(),\\n current: Scope::new(ScopeKind::Fn, None),\\n ident_type: IdentType::Ref,\\n var_kind: None,\\n };\\n\\n folder.ident_type = IdentType::Binding;\\n n.function.params.visit_mut_children_with(&mut folder);\\n\\n folder.ident_type = IdentType::Ref;\\n\\n n.function.body.visit_mut_with(self);\\n n.key.visit_mut_with(self);\\n\\n folder.apply_ops(&mut n.function);\\n }\\n\\n fn visit_mut_constructor(&mut self, c: &mut Constructor) {\\n let mut folder = Hygiene {\\n config: self.config.clone(),\\n current: Scope::new(ScopeKind::Fn, None),\\n ident_type: IdentType::Ref,\\n var_kind: None,\\n };\\n\\n let old = folder.ident_type;\\n folder.ident_type = IdentType::Binding;\\n c.params.visit_mut_with(&mut folder);\\n folder.ident_type = old;\\n\\n c.body\\n .as_mut()\\n .map(|bs| bs.visit_mut_children_with(&mut folder));\\n c.key.visit_mut_with(&mut folder);\\n\\n folder.apply_ops(c)\\n }\\n\\n fn visit_mut_decl(&mut self, decl: &mut Decl) {\\n match decl {\\n Decl::Class(cls) if self.config.keep_class_names => {\\n let span = cls.class.span;\\n\\n let expr = self.keep_class_name(&mut cls.ident, &mut cls.class);\\n if let Some(expr) = expr {\\n let var = VarDeclarator {\\n span,\\n name: Pat::Ident(cls.ident.clone().into()),\\n init: Some(Box::new(Expr::Class(expr))),\\n definite: false,\\n };\\n *decl = Decl::Var(VarDecl {\\n span,\\n kind: VarDeclKind::Let,\\n declare: false,\\n decls: vec![var],\\n });\\n return;\\n }\\n\\n return;\\n }\\n _ => {}\\n }\\n\\n decl.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_expr(&mut self, node: &mut Expr) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Ref;\\n match node {\\n Expr::Ident(..) => node.visit_mut_children_with(self),\\n\\n Expr::This(..) => {}\\n\\n _ => node.visit_mut_children_with(self),\\n };\\n\\n self.ident_type = old;\\n }\\n\\n fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {\\n let mut new_id = Some(node.ident.clone());\\n self.visit_mut_fn(&mut new_id, &mut node.function, true);\\n node.ident = new_id.unwrap();\\n }\\n\\n fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {\\n let mut new_id = node.ident.clone();\\n self.visit_mut_fn(&mut new_id, &mut node.function, false);\\n node.ident = new_id;\\n }\\n\\n /// Invoked for `IdentifierReference` / `BindingIdentifier`\\n fn visit_mut_ident(&mut self, i: &mut Ident) {\\n if i.sym == js_word!(\"arguments\") || i.sym == js_word!(\"undefined\") {\\n return;\\n }\\n\\n match self.ident_type {\\n IdentType::Binding => self.add_decl(i.clone()),\\n IdentType::Ref => {\\n // Special cases\\n if is_native_word(&i.sym) {\\n return;\\n }\\n\\n self.add_used_ref(&i);\\n }\\n IdentType::Label => {\\n // We currently does not touch labels\\n return;\\n }\\n }\\n }\\n\\n fn visit_mut_member_expr(&mut self, e: &mut MemberExpr) {\\n e.obj.visit_mut_with(self);\\n\\n if e.computed {\\n e.prop.visit_mut_with(self);\\n }\\n }\\n\\n fn visit_mut_module(&mut self, module: &mut Module) {\\n module.visit_mut_children_with(self);\\n\\n self.apply_ops(module)\\n }\\n\\n fn visit_mut_private_name(&mut self, _: &mut PrivateName) {}\\n\\n fn visit_mut_setter_prop(&mut self, f: &mut SetterProp) {\\n let old = self.ident_type;\\n self.ident_type = IdentType::Ref;\\n f.key.visit_mut_with(self);\\n self.ident_type = old;\\n\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n f.param.visit_mut_with(self);\\n self.ident_type = old;\\n\\n f.body.visit_mut_with(self);\\n }\\n\\n fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {\\n node.block.visit_mut_children_with(self);\\n\\n node.handler.visit_mut_with(self);\\n node.finalizer.visit_mut_children_with(self);\\n }\\n\\n fn visit_mut_var_decl(&mut self, var: &mut VarDecl) {\\n let old = self.var_kind;\\n self.var_kind = Some(var.kind);\\n var.visit_mut_children_with(self);\\n self.var_kind = old;\\n }\\n\\n fn visit_mut_var_declarator(&mut self, decl: &mut VarDeclarator) {\\n let old = self.var_kind;\\n self.var_kind = None;\\n decl.init.visit_mut_with(self);\\n self.var_kind = old;\\n\\n let old = self.ident_type;\\n self.ident_type = IdentType::Binding;\\n decl.name.visit_mut_with(self);\\n self.ident_type = old;\\n }\\n}\\n',\n", + " 'content_id': '7927a93ee9842a363ad34ed1146af5a7cb52bee7',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 95,\n", + " 'path': '/ecmascript/transforms/base/src/hygiene/mod.rs',\n", + " 'size': 29110,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.6614052953156823,\n", + " 'avg_line_length': 41.69565217391305,\n", + " 'blob_id': 'a73c6df0c9c356682dd9da8d1505adcd38e86a81',\n", + " 'content': '[package]\\nauthors = [\"강동윤 \"]\\ndescription = \"rust port of babel and closure compiler.\"\\ndocumentation = \"https://rustdoc.swc.rs/swc_ecma_transforms/\"\\nedition = \"2018\"\\nlicense = \"Apache-2.0/MIT\"\\nname = \"swc_ecma_transforms\"\\nrepository = \"https://github.com/swc-project/swc.git\"\\nversion = \"0.80.0\"\\n\\n[package.metadata.docs.rs]\\nall-features = true\\n\\n[features]\\ncompat = [\"swc_ecma_transforms_compat\"]\\nmodule = [\"swc_ecma_transforms_module\"]\\nmulti-module-decorator = [\"swc_ecma_transforms_proposal/multi-module\"]\\noptimization = [\"swc_ecma_transforms_optimization\"]\\nproposal = [\"swc_ecma_transforms_proposal\"]\\nreact = [\"swc_ecma_transforms_react\"]\\ntypescript = [\"swc_ecma_transforms_typescript\"]\\n\\n[dependencies]\\nswc_atoms = {version = \"0.2.0\", path = \"../../atoms\"}\\nswc_common = {version = \"0.13.0\", path = \"../../common\"}\\nswc_ecma_ast = {version = \"0.54.0\", path = \"../ast\"}\\nswc_ecma_parser = {version = \"0.73.0\", path = \"../parser\"}\\nswc_ecma_transforms_base = {version = \"0.35.0\", path = \"./base\"}\\nswc_ecma_transforms_compat = {version = \"0.40.0\", path = \"./compat\", optional = true}\\nswc_ecma_transforms_module = {version = \"0.44.0\", path = \"./module\", optional = true}\\nswc_ecma_transforms_optimization = {version = \"0.50.0\", path = \"./optimization\", optional = true}\\nswc_ecma_transforms_proposal = {version = \"0.44.0\", path = \"./proposal\", optional = true}\\nswc_ecma_transforms_react = {version = \"0.46.0\", path = \"./react\", optional = true}\\nswc_ecma_transforms_typescript = {version = \"0.46.1\", path = \"./typescript\", optional = true}\\nswc_ecma_utils = {version = \"0.46.0\", path = \"../utils\"}\\nswc_ecma_visit = {version = \"0.40.0\", path = \"../visit\"}\\nunicode-xid = \"0.2\"\\n\\n[dev-dependencies]\\npretty_assertions = \"0.6\"\\nsourcemap = \"6\"\\nswc_ecma_codegen = {version = \"0.74.0\", path = \"../codegen\"}\\nswc_ecma_transforms_testing = {version = \"0.36.0\", path = \"./testing\"}\\ntempfile = \"3\"\\ntesting = {version = \"0.14.0\", path = \"../../testing\"}\\nwalkdir = \"2\"\\n',\n", + " 'content_id': 'af14073ce8db6ff31a05756003005855a572aa8d',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'toml',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'TOML',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 97,\n", + " 'path': '/ecmascript/transforms/Cargo.toml',\n", + " 'size': 1964,\n", + " 'src_encoding': 'UTF-8'},\n", + " {'alphanum_fraction': 0.5331055104656129,\n", + " 'avg_line_length': 25.928680981595093,\n", + " 'blob_id': '68eb6753c15d9592936d462636498da60d504e59',\n", + " 'content': 'use self::util::BoolOrObject;\\nuse crate::{builder::PassBuilder, SwcComments, SwcImportResolver};\\nuse anyhow::{bail, Context, Error};\\nuse dashmap::DashMap;\\nuse either::Either;\\nuse once_cell::sync::Lazy;\\nuse regex::Regex;\\nuse rustc_hash::{FxHashMap, FxHashSet};\\nuse serde::{Deserialize, Serialize};\\nuse std::{\\n cell::RefCell,\\n collections::{HashMap, HashSet},\\n env,\\n hash::BuildHasher,\\n path::{Path, PathBuf},\\n rc::Rc as RustRc,\\n sync::Arc,\\n usize,\\n};\\nuse swc_atoms::JsWord;\\npub use swc_common::chain;\\nuse swc_common::{errors::Handler, FileName, Mark, SourceMap};\\nuse swc_ecma_ast::{Expr, ExprStmt, ModuleItem, Stmt};\\nuse swc_ecma_ext_transforms::jest;\\nuse swc_ecma_loader::resolvers::{\\n lru::CachingResolver, node::NodeModulesResolver, tsc::TsConfigResolver,\\n};\\nuse swc_ecma_minifier::option::{\\n terser::{TerserCompressorOptions, TerserEcmaVersion},\\n MangleOptions, ManglePropertiesOptions,\\n};\\npub use swc_ecma_parser::JscTarget;\\nuse swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax, TsConfig};\\nuse swc_ecma_transforms::{\\n hygiene, modules,\\n modules::{hoist::import_hoister, path::NodeImportResolver, util::Scope},\\n optimization::{const_modules, inline_globals, json_parse, simplifier},\\n pass::{noop, Optional},\\n proposals::{decorators, export_default_from, import_assertions},\\n react, resolver_with_mark, typescript,\\n};\\nuse swc_ecma_visit::Fold;\\n\\n#[cfg(test)]\\nmod tests;\\npub mod util;\\n\\n#[derive(Default, Clone, Serialize, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\npub struct ParseOptions {\\n #[serde(default)]\\n pub comments: bool,\\n #[serde(flatten)]\\n pub syntax: Syntax,\\n\\n #[serde(default = \"default_is_module\")]\\n pub is_module: bool,\\n\\n #[serde(default)]\\n pub target: JscTarget,\\n}\\n\\n#[derive(Debug, Clone, Default, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct Options {\\n #[serde(flatten)]\\n pub config: Config,\\n\\n #[serde(skip_deserializing, default)]\\n pub skip_helper_injection: bool,\\n\\n #[serde(skip_deserializing, default)]\\n pub disable_hygiene: bool,\\n\\n #[serde(skip_deserializing, default)]\\n pub disable_fixer: bool,\\n\\n #[serde(skip_deserializing, default)]\\n pub global_mark: Option,\\n\\n #[cfg(not(target_arch = \"wasm32\"))]\\n #[serde(default = \"default_cwd\")]\\n pub cwd: PathBuf,\\n\\n #[serde(default)]\\n pub caller: Option,\\n\\n #[serde(default)]\\n pub filename: String,\\n\\n #[serde(default)]\\n pub config_file: Option,\\n\\n #[serde(default)]\\n pub root: Option,\\n\\n #[serde(default)]\\n pub root_mode: RootMode,\\n\\n #[serde(default = \"default_swcrc\")]\\n pub swcrc: bool,\\n\\n #[cfg(not(target_arch = \"wasm32\"))]\\n #[serde(default)]\\n pub swcrc_roots: Option,\\n\\n #[serde(default = \"default_env_name\")]\\n pub env_name: String,\\n\\n #[serde(default)]\\n pub source_maps: Option,\\n\\n #[serde(default)]\\n pub source_file_name: Option,\\n\\n #[serde(default)]\\n pub source_root: Option,\\n\\n #[serde(default = \"default_is_module\")]\\n pub is_module: bool,\\n\\n #[serde(default)]\\n pub output_path: Option,\\n}\\n\\nimpl Options {\\n pub fn codegen_target(&self) -> Option {\\n self.config.jsc.target\\n }\\n}\\n\\nfn default_is_module() -> bool {\\n true\\n}\\n\\n/// Configuration related to source map generated by swc.\\n#[derive(Clone, Serialize, Deserialize, Debug)]\\n#[serde(untagged)]\\npub enum SourceMapsConfig {\\n Bool(bool),\\n Str(String),\\n}\\n\\nimpl SourceMapsConfig {\\n pub fn enabled(&self) -> bool {\\n match *self {\\n SourceMapsConfig::Bool(b) => b,\\n SourceMapsConfig::Str(ref s) => {\\n assert_eq!(s, \"inline\", \"Source map must be true, false or inline\");\\n true\\n }\\n }\\n }\\n}\\n\\nimpl Default for SourceMapsConfig {\\n fn default() -> Self {\\n SourceMapsConfig::Bool(true)\\n }\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(untagged)]\\npub enum InputSourceMap {\\n Bool(bool),\\n Str(String),\\n}\\n\\nimpl Default for InputSourceMap {\\n fn default() -> Self {\\n InputSourceMap::Bool(false)\\n }\\n}\\n\\nimpl Options {\\n pub fn build<\\'a>(\\n &self,\\n cm: &Arc,\\n base: &FileName,\\n output_path: Option<&Path>,\\n source_file_name: Option,\\n handler: &Handler,\\n is_module: bool,\\n config: Option,\\n comments: Option<&\\'a SwcComments>,\\n custom_before_pass: impl \\'a + swc_ecma_visit::Fold,\\n ) -> BuiltConfig {\\n let mut config = config.unwrap_or_else(Default::default);\\n config.merge(&self.config);\\n\\n let mut source_maps = self.source_maps.clone();\\n source_maps.merge(&config.source_maps);\\n\\n let JscConfig {\\n transform,\\n syntax,\\n external_helpers,\\n target,\\n loose,\\n keep_class_names,\\n base_url,\\n paths,\\n minify: js_minify,\\n ..\\n } = config.jsc;\\n\\n let target = target.unwrap_or_default();\\n\\n let syntax = syntax.unwrap_or_default();\\n let mut transform = transform.unwrap_or_default();\\n\\n let preserve_comments = js_minify.as_ref().map(|v| v.format.comments.clone());\\n\\n if syntax.typescript() {\\n transform.legacy_decorator = true;\\n }\\n let optimizer = transform.optimizer;\\n let enable_optimizer = optimizer.is_some();\\n\\n let const_modules = {\\n let enabled = transform.const_modules.is_some();\\n let config = transform.const_modules.unwrap_or_default();\\n\\n let globals = config.globals;\\n Optional::new(const_modules(cm.clone(), globals), enabled)\\n };\\n\\n let json_parse_pass = {\\n if let Some(ref cfg) = optimizer.as_ref().and_then(|v| v.jsonify) {\\n Either::Left(json_parse(cfg.min_cost))\\n } else {\\n Either::Right(noop())\\n }\\n };\\n\\n let optimization = {\\n let pass =\\n if let Some(opts) = optimizer.map(|o| o.globals.unwrap_or_else(Default::default)) {\\n opts.build(cm, handler)\\n } else {\\n GlobalPassOption::default().build(cm, handler)\\n };\\n\\n pass\\n };\\n\\n let top_level_mark = self\\n .global_mark\\n .unwrap_or_else(|| Mark::fresh(Mark::root()));\\n\\n let pass = chain!(\\n const_modules,\\n optimization,\\n Optional::new(export_default_from(), syntax.export_default_from()),\\n Optional::new(simplifier(Default::default()), enable_optimizer),\\n json_parse_pass\\n );\\n\\n let pass = PassBuilder::new(&cm, &handler, loose, top_level_mark, pass)\\n .target(target)\\n .skip_helper_injection(self.skip_helper_injection)\\n .minify(js_minify)\\n .hygiene(if self.disable_hygiene {\\n None\\n } else {\\n Some(hygiene::Config { keep_class_names })\\n })\\n .fixer(!self.disable_fixer)\\n .preset_env(config.env)\\n .finalize(\\n base_url,\\n paths.into_iter().collect(),\\n base,\\n syntax,\\n config.module,\\n comments,\\n );\\n\\n let pass = chain!(\\n // Decorators may use type information\\n Optional::new(\\n decorators(decorators::Config {\\n legacy: transform.legacy_decorator,\\n emit_metadata: transform.decorator_metadata,\\n }),\\n syntax.decorators()\\n ),\\n import_assertions(),\\n Optional::new(typescript::strip(), syntax.typescript()),\\n resolver_with_mark(top_level_mark),\\n custom_before_pass,\\n // handle jsx\\n Optional::new(\\n react::react(\\n cm.clone(),\\n comments.clone(),\\n transform.react,\\n top_level_mark\\n ),\\n syntax.jsx()\\n ),\\n pass,\\n Optional::new(jest::jest(), transform.hidden.jest)\\n );\\n\\n BuiltConfig {\\n minify: config.minify,\\n pass,\\n external_helpers,\\n syntax,\\n target,\\n is_module,\\n source_maps: source_maps.unwrap_or(SourceMapsConfig::Bool(false)),\\n inline_sources_content: config.inline_sources_content,\\n input_source_map: self.config.input_source_map.clone(),\\n output_path: output_path.map(|v| v.to_path_buf()),\\n source_file_name,\\n preserve_comments,\\n }\\n }\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]\\npub enum RootMode {\\n #[serde(rename = \"root\")]\\n Root,\\n #[serde(rename = \"upward\")]\\n Upward,\\n #[serde(rename = \"upward-optional\")]\\n UpwardOptional,\\n}\\n\\nimpl Default for RootMode {\\n fn default() -> Self {\\n RootMode::Root\\n }\\n}\\nconst fn default_swcrc() -> bool {\\n true\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(untagged)]\\npub enum ConfigFile {\\n Bool(bool),\\n Str(String),\\n}\\n\\nimpl Default for ConfigFile {\\n fn default() -> Self {\\n ConfigFile::Bool(true)\\n }\\n}\\n\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(rename_all = \"camelCase\")]\\npub struct CallerOptions {\\n pub name: String,\\n}\\n\\n#[cfg(not(target_arch = \"wasm32\"))]\\nfn default_cwd() -> PathBuf {\\n ::std::env::current_dir().unwrap()\\n}\\n\\n/// `.swcrc` file\\n#[derive(Debug, Clone, Deserialize)]\\n#[serde(untagged, rename = \"swcrc\")]\\npub enum Rc {\\n Single(Config),\\n Multi(Vec),\\n}\\n\\nimpl Default for Rc {\\n fn default() -> Self {\\n Rc::Multi(vec![\\n Config {\\n env: None,\\n test: None,\\n exclude: Some(FileMatcher::Regex(\"\\\\\\\\.tsx?$\".into())),\\n jsc: JscConfig {\\n syntax: Some(Default::default()),\\n transform: None,\\n external_helpers: false,\\n target: Default::default(),\\n loose: false,\\n keep_class_names: false,\\n ..Default::default()\\n },\\n module: None,\\n minify: false,\\n source_maps: None,\\n input_source_map: InputSourceMap::default(),\\n ..Default::default()\\n },\\n Config {\\n env: None,\\n test: Some(FileMatcher::Regex(\"\\\\\\\\.tsx$\".into())),\\n exclude: None,\\n jsc: JscConfig {\\n syntax: Some(Syntax::Typescript(TsConfig {\\n tsx: true,\\n ..Default::default()\\n })),\\n transform: None,\\n external_helpers: false,\\n target: Default::default(),\\n loose: false,\\n keep_class_names: false,\\n ..Default::default()\\n },\\n module: None,\\n minify: false,\\n source_maps: None,\\n input_source_map: InputSourceMap::default(),\\n ..Default::default()\\n },\\n Config {\\n env: None,\\n test: Some(FileMatcher::Regex(\"\\\\\\\\.ts$\".into())),\\n exclude: None,\\n jsc: JscConfig {\\n syntax: Some(Syntax::Typescript(TsConfig {\\n tsx: false,\\n ..Default::default()\\n })),\\n transform: None,\\n external_helpers: false,\\n target: Default::default(),\\n loose: false,\\n keep_class_names: false,\\n ..Default::default()\\n },\\n module: None,\\n minify: false,\\n source_maps: None,\\n input_source_map: InputSourceMap::default(),\\n ..Default::default()\\n },\\n ])\\n }\\n}\\n\\nimpl Rc {\\n /// This method returns `Ok(None)` if the file should be ignored.\\n pub fn into_config(self, filename: Option<&Path>) -> Result, Error> {\\n let cs = match self {\\n Rc::Single(mut c) => match filename {\\n Some(filename) => {\\n if c.matches(filename)? {\\n c.adjust(filename);\\n\\n return Ok(Some(c));\\n } else {\\n return Ok(None);\\n }\\n }\\n // TODO\\n None => return Ok(Some(c)),\\n },\\n Rc::Multi(cs) => cs,\\n };\\n\\n match filename {\\n Some(filename) => {\\n for mut c in cs {\\n if c.matches(filename)? {\\n c.adjust(filename);\\n\\n return Ok(Some(c));\\n }\\n }\\n }\\n None => return Ok(Some(Config::default())),\\n }\\n\\n bail!(\".swcrc exists but not matched\")\\n }\\n}\\n\\n/// A single object in the `.swcrc` file\\n#[derive(Debug, Default, Clone, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct Config {\\n #[serde(default)]\\n pub env: Option,\\n\\n #[serde(default)]\\n pub test: Option,\\n\\n #[serde(default)]\\n pub exclude: Option,\\n\\n #[serde(default)]\\n pub jsc: JscConfig,\\n\\n #[serde(default)]\\n pub module: Option,\\n\\n #[serde(default)]\\n pub minify: bool,\\n\\n #[serde(default)]\\n pub input_source_map: InputSourceMap,\\n\\n /// Possible values are: `\\'inline\\'`, `true`, `false`.\\n #[serde(default)]\\n pub source_maps: Option,\\n\\n #[serde(default)]\\n pub inline_sources_content: bool,\\n}\\n\\n/// Second argument of `minify`.\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct JsMinifyOptions {\\n #[serde(default)]\\n pub compress: BoolOrObject,\\n\\n #[serde(default)]\\n pub mangle: BoolOrObject,\\n\\n #[serde(default)]\\n pub format: JsMinifyFormatOptions,\\n\\n #[serde(default)]\\n pub ecma: TerserEcmaVersion,\\n\\n #[serde(default)]\\n pub keep_classnames: bool,\\n\\n #[serde(default)]\\n pub keep_fnames: bool,\\n\\n #[serde(default)]\\n pub module: bool,\\n\\n #[serde(default)]\\n pub safari10: bool,\\n\\n #[serde(default)]\\n pub toplevel: bool,\\n\\n #[serde(default)]\\n pub source_map: BoolOrObject,\\n\\n #[serde(default)]\\n pub output_path: Option,\\n\\n #[serde(default)]\\n pub inline_sources_content: bool,\\n}\\n/// `jsc.minify.sourceMap`\\n#[derive(Debug, Clone, Default, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct TerserSourceMapOption {\\n #[serde(default)]\\n pub filename: Option,\\n\\n #[serde(default)]\\n pub url: Option,\\n\\n #[serde(default)]\\n pub root: Option,\\n\\n #[serde(default)]\\n pub content: Option,\\n}\\n\\n/// `jsc.minify.format`.\\n#[derive(Debug, Clone, Default, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct JsMinifyFormatOptions {\\n /// Not implemented yet.\\n #[serde(default, alias = \"ascii_only\")]\\n pub ascii_only: bool,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub beautify: bool,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub braces: bool,\\n\\n #[serde(default)]\\n pub comments: BoolOrObject,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub ecma: usize,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"indent_level\")]\\n pub indent_level: usize,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"indent_start\")]\\n pub indent_start: bool,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"inline_script\")]\\n pub inline_script: bool,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"keep_numbers\")]\\n pub keep_numbers: bool,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"keep_quoted_props\")]\\n pub keep_quoted_props: bool,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"max_line_len\")]\\n pub max_line_len: BoolOrObject,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub preamble: String,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"quote_keys\")]\\n pub quote_keys: bool,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"quote_style\")]\\n pub quote_style: usize,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"preserve_annotations\")]\\n pub preserve_annotations: bool,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub safari10: bool,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub semicolons: bool,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub shebang: bool,\\n\\n /// Not implemented yet.\\n #[serde(default)]\\n pub webkit: bool,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"warp_iife\")]\\n pub wrap_iife: bool,\\n\\n /// Not implemented yet.\\n #[serde(default, alias = \"wrap_func_args\")]\\n pub wrap_func_args: bool,\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\npub enum JsMinifyCommentOption {\\n #[serde(rename = \"some\")]\\n PreserveSomeComments,\\n #[serde(rename = \"all\")]\\n PreserveAllComments,\\n}\\n\\nimpl Default for JsMinifyCommentOption {\\n fn default() -> Self {\\n JsMinifyCommentOption::PreserveSomeComments\\n }\\n}\\n\\nimpl Config {\\n /// Adjust config for `file`.\\n ///\\n ///\\n ///\\n /// - typescript: `tsx` will be modified if file extension is `ts`.\\n pub fn adjust(&mut self, file: &Path) {\\n match &mut self.jsc.syntax {\\n Some(Syntax::Typescript(TsConfig { tsx, .. })) => {\\n let is_ts = file.extension().map(|v| v == \"ts\").unwrap_or(false);\\n if is_ts {\\n *tsx = false;\\n }\\n }\\n _ => {}\\n }\\n }\\n}\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(untagged)]\\npub enum FileMatcher {\\n Regex(String),\\n Multi(Vec),\\n}\\n\\nimpl Default for FileMatcher {\\n fn default() -> Self {\\n Self::Regex(String::from(\"\"))\\n }\\n}\\n\\nimpl FileMatcher {\\n pub fn matches(&self, filename: &Path) -> Result {\\n static CACHE: Lazy> = Lazy::new(Default::default);\\n\\n match self {\\n FileMatcher::Regex(ref s) => {\\n if s.is_empty() {\\n return Ok(false);\\n }\\n\\n if !CACHE.contains_key(&*s) {\\n let re = Regex::new(&s).with_context(|| format!(\"invalid regex: {}\", s))?;\\n CACHE.insert(s.clone(), re);\\n }\\n\\n let re = CACHE.get(&*s).unwrap();\\n\\n let filename = if cfg!(target_os = \"windows\") {\\n filename.to_string_lossy().replace(\"\\\\\\\\\", \"/\")\\n } else {\\n filename.to_string_lossy().to_string()\\n };\\n\\n Ok(re.is_match(&filename))\\n }\\n FileMatcher::Multi(ref v) => {\\n //\\n for m in v {\\n if m.matches(filename)? {\\n return Ok(true);\\n }\\n }\\n\\n Ok(false)\\n }\\n }\\n }\\n}\\n\\nimpl Config {\\n pub fn matches(&self, filename: &Path) -> Result {\\n if let Some(ref exclude) = self.exclude {\\n if exclude.matches(filename)? {\\n return Ok(false);\\n }\\n }\\n\\n if let Some(ref include) = self.test {\\n if include.matches(filename)? {\\n return Ok(true);\\n }\\n return Ok(false);\\n }\\n\\n Ok(true)\\n }\\n}\\n\\n/// One `BuiltConfig` per a directory with swcrc\\npub struct BuiltConfig {\\n pub pass: P,\\n pub syntax: Syntax,\\n pub target: JscTarget,\\n /// Minification for **codegen**. Minifier transforms will be inserted into\\n /// `pass`.\\n pub minify: bool,\\n pub external_helpers: bool,\\n pub source_maps: SourceMapsConfig,\\n pub input_source_map: InputSourceMap,\\n pub is_module: bool,\\n pub output_path: Option,\\n\\n pub source_file_name: Option,\\n\\n pub preserve_comments: Option>,\\n\\n pub inline_sources_content: bool,\\n}\\n\\n/// `jsc` in `.swcrc`.\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct JscConfig {\\n #[serde(rename = \"parser\", default)]\\n pub syntax: Option,\\n\\n #[serde(default)]\\n pub transform: Option,\\n\\n #[serde(default)]\\n pub external_helpers: bool,\\n\\n #[serde(default)]\\n pub target: Option,\\n\\n #[serde(default)]\\n pub loose: bool,\\n\\n #[serde(default)]\\n pub keep_class_names: bool,\\n\\n #[serde(default)]\\n pub base_url: PathBuf,\\n\\n #[serde(default)]\\n pub paths: Paths,\\n\\n #[serde(default)]\\n pub minify: Option,\\n\\n #[serde(default)]\\n pub experimental: JscExperimental,\\n}\\n\\n/// `jsc.experimental` in `.swcrc`\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct JscExperimental {}\\n\\nimpl Merge for JscExperimental {\\n fn merge(&mut self, _from: &Self) {}\\n}\\n\\n/// `paths` sectiob of `tsconfig.json`.\\npub type Paths = HashMap, ahash::RandomState>;\\npub(crate) type CompiledPaths = Vec<(String, Vec)>;\\n\\n#[derive(Debug, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\n#[serde(tag = \"type\")]\\npub enum ModuleConfig {\\n #[serde(rename = \"commonjs\")]\\n CommonJs(modules::common_js::Config),\\n #[serde(rename = \"umd\")]\\n Umd(modules::umd::Config),\\n #[serde(rename = \"amd\")]\\n Amd(modules::amd::Config),\\n #[serde(rename = \"es6\")]\\n Es6,\\n}\\n\\nimpl ModuleConfig {\\n pub fn build(\\n cm: Arc,\\n base_url: PathBuf,\\n paths: CompiledPaths,\\n base: &FileName,\\n root_mark: Mark,\\n config: Option,\\n scope: RustRc>,\\n ) -> Box {\\n let base = match base {\\n FileName::Real(v) if !paths.is_empty() => {\\n FileName::Real(v.canonicalize().unwrap_or_else(|_| v.to_path_buf()))\\n }\\n _ => base.clone(),\\n };\\n\\n match config {\\n None | Some(ModuleConfig::Es6) => Box::new(import_hoister()),\\n Some(ModuleConfig::CommonJs(config)) => {\\n if paths.is_empty() {\\n Box::new(modules::common_js::common_js(\\n root_mark,\\n config,\\n Some(scope),\\n ))\\n } else {\\n let resolver = build_resolver(base_url, paths);\\n\\n Box::new(modules::common_js::common_js_with_resolver(\\n resolver,\\n base,\\n root_mark,\\n config,\\n Some(scope),\\n ))\\n }\\n }\\n Some(ModuleConfig::Umd(config)) => {\\n if paths.is_empty() {\\n Box::new(modules::umd::umd(cm, root_mark, config))\\n } else {\\n let resolver = build_resolver(base_url, paths);\\n\\n Box::new(modules::umd::umd_with_resolver(\\n resolver, base, cm, root_mark, config,\\n ))\\n }\\n }\\n Some(ModuleConfig::Amd(config)) => {\\n if paths.is_empty() {\\n Box::new(modules::amd::amd(config))\\n } else {\\n let resolver = build_resolver(base_url, paths);\\n\\n Box::new(modules::amd::amd_with_resolver(resolver, base, config))\\n }\\n }\\n }\\n }\\n}\\n\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct TransformConfig {\\n #[serde(default)]\\n pub react: react::Options,\\n\\n #[serde(default)]\\n pub const_modules: Option,\\n\\n #[serde(default)]\\n pub optimizer: Option,\\n\\n #[serde(default)]\\n pub legacy_decorator: bool,\\n\\n #[serde(default)]\\n pub decorator_metadata: bool,\\n\\n #[serde(default)]\\n pub hidden: HiddenTransformConfig,\\n}\\n\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct HiddenTransformConfig {\\n #[serde(default)]\\n pub jest: bool,\\n}\\n\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct ConstModulesConfig {\\n #[serde(default)]\\n pub globals: HashMap>,\\n}\\n\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct OptimizerConfig {\\n #[serde(default)]\\n pub globals: Option,\\n\\n #[serde(default)]\\n pub jsonify: Option,\\n}\\n\\n#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct JsonifyOption {\\n #[serde(default = \"default_jsonify_min_cost\")]\\n pub min_cost: usize,\\n}\\n\\nfn default_jsonify_min_cost() -> usize {\\n 1024\\n}\\n\\n#[derive(Debug, Default, Clone, Serialize, Deserialize)]\\n#[serde(deny_unknown_fields, rename_all = \"camelCase\")]\\npub struct GlobalPassOption {\\n #[serde(default)]\\n pub vars: FxHashMap,\\n #[serde(default = \"default_envs\")]\\n pub envs: FxHashSet,\\n}\\n\\nfn default_envs() -> FxHashSet {\\n let mut v = HashSet::default();\\n v.insert(String::from(\"NODE_ENV\"));\\n v.insert(String::from(\"SWC_ENV\"));\\n v\\n}\\n\\nimpl GlobalPassOption {\\n pub fn build(self, cm: &SourceMap, handler: &Handler) -> impl \\'static + Fold {\\n type ValuesMap = Arc>;\\n\\n fn mk_map(\\n cm: &SourceMap,\\n handler: &Handler,\\n values: impl Iterator,\\n is_env: bool,\\n ) -> ValuesMap {\\n let mut m = HashMap::default();\\n\\n for (k, v) in values {\\n let v = if is_env {\\n format!(\"\\'{}\\'\", v)\\n } else {\\n (*v).into()\\n };\\n let v_str = v.clone();\\n let fm = cm.new_source_file(FileName::Custom(format!(\"GLOBAL.{}\", k)), v);\\n let lexer = Lexer::new(\\n Syntax::Es(Default::default()),\\n Default::default(),\\n StringInput::from(&*fm),\\n None,\\n );\\n\\n let mut p = Parser::new_from(lexer);\\n let module = p.parse_module();\\n\\n for e in p.take_errors() {\\n e.into_diagnostic(handler).emit()\\n }\\n\\n let mut module = module\\n .map_err(|e| e.into_diagnostic(handler).emit())\\n .unwrap_or_else(|()| {\\n panic!(\\n \"failed to parse global variable {}=`{}` as module\",\\n k, v_str\\n )\\n });\\n\\n let expr = match module.body.pop() {\\n Some(ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. }))) => *expr,\\n _ => panic!(\"{} is not a valid expression\", v_str),\\n };\\n\\n m.insert((*k).into(), expr);\\n }\\n\\n Arc::new(m)\\n }\\n\\n let env_map = if cfg!(target_arch = \"wasm32\") {\\n Arc::new(Default::default())\\n } else {\\n static CACHE: Lazy, ValuesMap>> = Lazy::new(|| Default::default());\\n\\n let cache_key = self.envs.iter().cloned().collect::>();\\n if let Some(v) = CACHE.get(&cache_key).as_deref().cloned() {\\n v\\n } else {\\n let envs = self.envs;\\n let map = mk_map(\\n cm,\\n handler,\\n env::vars().filter(|(k, _)| envs.contains(&*k)),\\n true,\\n );\\n CACHE.insert(cache_key, map.clone());\\n map\\n }\\n };\\n\\n let global_map = {\\n static CACHE: Lazy, ValuesMap>> =\\n Lazy::new(|| Default::default());\\n\\n let cache_key = self\\n .vars\\n .iter()\\n .map(|(k, v)| (k.clone(), v.clone()))\\n .collect::>();\\n if let Some(v) = CACHE.get(&cache_key) {\\n (*v).clone()\\n } else {\\n let map = mk_map(cm, handler, self.vars.into_iter(), false);\\n CACHE.insert(cache_key, map.clone());\\n map\\n }\\n };\\n\\n inline_globals(env_map, global_map)\\n }\\n}\\n\\nfn default_env_name() -> String {\\n match env::var(\"SWC_ENV\") {\\n Ok(v) => return v,\\n Err(_) => {}\\n }\\n\\n match env::var(\"NODE_ENV\") {\\n Ok(v) => v,\\n Err(_) => \"development\".into(),\\n }\\n}\\n\\npub trait Merge {\\n /// Apply overrides from `from`\\n fn merge(&mut self, from: &Self);\\n}\\n\\nimpl Merge for Option\\nwhere\\n T: Merge,\\n{\\n fn merge(&mut self, from: &Option) {\\n match *from {\\n Some(ref from) => match *self {\\n Some(ref mut v) => v.merge(from),\\n None => *self = Some(from.clone()),\\n },\\n // no-op\\n None => {}\\n }\\n }\\n}\\n\\nimpl Merge for Config {\\n fn merge(&mut self, from: &Self) {\\n self.jsc.merge(&from.jsc);\\n self.module.merge(&from.module);\\n self.minify.merge(&from.minify);\\n self.env.merge(&from.env);\\n self.source_maps.merge(&from.source_maps);\\n self.inline_sources_content\\n .merge(&from.inline_sources_content);\\n }\\n}\\n\\nimpl Merge for JsMinifyOptions {\\n fn merge(&mut self, from: &Self) {\\n self.compress.merge(&from.compress);\\n self.mangle.merge(&from.mangle);\\n self.format.merge(&from.format);\\n self.ecma.merge(&from.ecma);\\n self.keep_classnames |= from.keep_classnames;\\n self.keep_fnames |= from.keep_fnames;\\n self.safari10 |= from.safari10;\\n self.toplevel |= from.toplevel;\\n self.inline_sources_content |= from.inline_sources_content;\\n }\\n}\\n\\nimpl Merge for TerserCompressorOptions {\\n fn merge(&mut self, from: &Self) {\\n self.defaults |= from.defaults;\\n // TODO\\n }\\n}\\n\\nimpl Merge for MangleOptions {\\n fn merge(&mut self, from: &Self) {\\n self.props.merge(&from.props);\\n\\n self.top_level |= from.top_level;\\n self.keep_class_names |= from.keep_class_names;\\n self.keep_fn_names |= from.keep_fn_names;\\n self.keep_private_props |= from.keep_private_props;\\n self.safari10 |= from.safari10;\\n }\\n}\\n\\nimpl Merge for JsMinifyFormatOptions {\\n fn merge(&mut self, from: &Self) {\\n self.comments.merge(&from.comments);\\n }\\n}\\n\\nimpl Merge for JsMinifyCommentOption {\\n fn merge(&mut self, _: &Self) {}\\n}\\n\\nimpl Merge for ManglePropertiesOptions {\\n fn merge(&mut self, from: &Self) {\\n self.undeclared |= from.undeclared;\\n }\\n}\\n\\nimpl Merge for TerserEcmaVersion {\\n fn merge(&mut self, from: &Self) {\\n *self = from.clone();\\n }\\n}\\n\\nimpl Merge for SourceMapsConfig {\\n fn merge(&mut self, _: &Self) {}\\n}\\n\\nimpl Merge for swc_ecma_preset_env::Config {\\n fn merge(&mut self, from: &Self) {\\n *self = from.clone();\\n }\\n}\\n\\nimpl Merge for JscConfig {\\n fn merge(&mut self, from: &Self) {\\n self.syntax.merge(&from.syntax);\\n self.transform.merge(&from.transform);\\n self.target.merge(&from.target);\\n self.external_helpers.merge(&from.external_helpers);\\n self.keep_class_names.merge(&from.keep_class_names);\\n self.paths.merge(&from.paths);\\n self.minify.merge(&from.minify);\\n self.experimental.merge(&from.experimental);\\n }\\n}\\n\\nimpl Merge for HashMap\\nwhere\\n K: Clone + Eq + std::hash::Hash,\\n V: Clone,\\n S: Clone + BuildHasher,\\n{\\n fn merge(&mut self, from: &Self) {\\n if self.is_empty() {\\n *self = (*from).clone();\\n } else {\\n for (k, v) in from {\\n self.entry(k.clone()).or_insert(v.clone());\\n }\\n }\\n }\\n}\\n\\nimpl Merge for JscTarget {\\n fn merge(&mut self, from: &Self) {\\n if *self < *from {\\n *self = *from\\n }\\n }\\n}\\n\\nimpl Merge for Option {\\n fn merge(&mut self, from: &Self) {\\n match *from {\\n Some(ref c2) => *self = Some(c2.clone()),\\n None => {}\\n }\\n }\\n}\\n\\nimpl Merge for bool {\\n fn merge(&mut self, from: &Self) {\\n *self |= *from\\n }\\n}\\n\\nimpl Merge for Syntax {\\n fn merge(&mut self, from: &Self) {\\n *self = *from;\\n }\\n}\\n\\nimpl Merge for TransformConfig {\\n fn merge(&mut self, from: &Self) {\\n self.optimizer.merge(&from.optimizer);\\n self.const_modules.merge(&from.const_modules);\\n self.react.merge(&from.react);\\n }\\n}\\n\\nimpl Merge for OptimizerConfig {\\n fn merge(&mut self, from: &Self) {\\n self.globals.merge(&from.globals)\\n }\\n}\\n\\nimpl Merge for GlobalPassOption {\\n fn merge(&mut self, from: &Self) {\\n *self = from.clone();\\n }\\n}\\n\\nimpl Merge for react::Options {\\n fn merge(&mut self, from: &Self) {\\n if *from != react::Options::default() {\\n *self = from.clone();\\n }\\n }\\n}\\n\\nimpl Merge for ConstModulesConfig {\\n fn merge(&mut self, from: &Self) {\\n *self = from.clone()\\n }\\n}\\n\\nfn build_resolver(base_url: PathBuf, paths: CompiledPaths) -> SwcImportResolver {\\n static CACHE: Lazy> =\\n Lazy::new(|| Default::default());\\n\\n if let Some(cached) = CACHE.get(&(base_url.clone(), paths.clone())) {\\n return (*cached).clone();\\n }\\n\\n let r = {\\n let r = TsConfigResolver::new(\\n NodeModulesResolver::default(),\\n base_url.clone().into(),\\n paths.clone(),\\n );\\n let r = CachingResolver::new(40, r);\\n\\n let r = NodeImportResolver::new(r);\\n Arc::new(r)\\n };\\n\\n CACHE.insert((base_url, paths), r.clone());\\n\\n r\\n}\\n',\n", + " 'content_id': '81290ba96cfcc80d8e8a711af7c78e6b4b99a10a',\n", + " 'detected_licenses': ['MIT', 'Apache-2.0'],\n", + " 'directory_id': '88d0afe03d214a0c1320e26a99bdbe453cb32018',\n", + " 'ext': 'rs',\n", + " 'is_generated': False,\n", + " 'is_vendor': False,\n", + " 'language': 'Rust',\n", + " 'license_type': 'permissive',\n", + " 'max_line_length': 99,\n", + " 'path': '/src/config/mod.rs',\n", + " 'size': 35115,\n", + " 'src_encoding': 'UTF-8'}],\n", + " 'num_files': 102,\n", + " 'sc_length': 370495,\n", + " 'gpt4_length': 324237,\n", + " 'repo_language': 'Rust'}" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered3[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "64006dbf-801f-4c50-9fc2-0dd1ade90286", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ds[11]['files'])" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "be5cdaf3-5801-490c-8267-49b01ace5044", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR:root:('toml', 'lock'):lock not in ext_to_filter\n" + ] + } + ], + "source": [ + "files = filter_repo(ds[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "a88e6c14-794a-441a-8ffd-dbe0dcc65b72", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(files['files'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d800bc6-edfc-4f0d-9c8d-16fc767b92dd", + "metadata": {}, + "outputs": [], + "source": [ + "language = \"python\"\n", + "\n", + "per_extension_filter_csv = \"/home/toolkit/code/bigcode-dataset/preprocessing/visual_inspection.csv\"\n", + "ext_to_filter = load_filter_csv(args.per_extension_filter_csv)\n", + "\n", + "filtered = ds.filter(partial(basic_filters_per_extension, ext_to_filter=ext_to_filter))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}