added decoder module

Author: Danil42Russia

.gitignore

@@ -13,4 +13,4 @@ __pycache__/
 # Project
 /maps_list.txt
 /maps_files*
-/output
+/output*

README.md

@@ -1,3 +1,9 @@
 ## "JavaScript Source Maps Decoder
 
 Тут скоро будет описание. :)
+
+### Состав
+
+- [downloader](downloader.py)
+- [decoder](decoder.py)
+- [merger]()

common/__init__.py

@@ -0,0 +1,9 @@
+class Error:
+    message: str
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+
+
+def error(message: str) -> Error:
+    return Error(message)

common/error.py

@@ -0,0 +1,17 @@
+class MapCounter:
+    """Да, в Python есть [collections.Counter], но я захотел написать свой. :)"""
+
+    def __init__(self) -> None:
+        self._stats: dict[str, int] = {}
+        self._keys: list[str] = []
+
+    def increment(self, key: str) -> None:
+        if key not in self._keys:
+            self._stats[key] = 0
+            self._keys.append(key)
+
+        self._stats[key] += 1
+
+    @property
+    def total(self) -> dict[str, int]:
+        return self._stats

common/map_counter.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from typing import Self
+
+PyPath = Path | str
+
+
+class SafePath:
+    """Класс надстройка над [pathlib.Path], который не позволяет выйти за пределы указанного "базового" пути.
+
+    Оригинальный путь вычисляется при создании первого экземпляра данного класса.
+    При последующем join путей, "базовый" путь берётся от родительского пути.
+
+    >>> safe = SafePath("base")  # path: base, original_absolute: base
+    >>> safe2 = safe / "folder"  # path: base/folder, original_absolute: base
+    """
+
+    def __init__(self, path: PyPath) -> None:
+        save_path = Path(path)
+        self._safe_path = save_path
+        self._original_absolute: str = str(save_path.resolve().absolute())
+
+    def __truediv__(self, path_part: PyPath | Self) -> Self:
+        if isinstance(path_part, SafePath):
+            add_path_part = path_part.path
+        else:
+            add_path_part = Path(path_part)  # type: ignore [arg-type]
+
+        new_path = self._safe_path / add_path_part
+
+        new_absolute = str(new_path.resolve().absolute())
+        if not new_absolute.startswith(self._original_absolute):
+            raise RuntimeError(f"Путь '{new_absolute}' вышел из оригинального пути '{self._original_absolute}'")
+
+        save_path = SafePath(new_path)
+        save_path._set_absolute(self._original_absolute)
+        return save_path  # type: ignore [return-value]
+
+    def _set_absolute(self, absolute_path: str) -> None:
+        self._original_absolute = absolute_path
+
+    @property
+    def path(self) -> Path:
+        return self._safe_path
+
+
+def safe_path_join(original_path: PyPath, path_part: PyPath) -> Path:
+    new_path = SafePath(original_path) / path_part
+    return new_path.path

common/safe_path.py

@@ -0,0 +1,76 @@
+import json
+from pathlib import Path
+from typing import Any, NamedTuple, TypedDict
+
+from common.error import Error, error
+from common.map_counter import MapCounter
+
+
+class SourceMap(NamedTuple):
+    version: int
+    sources: list[str]
+    names: list[str] | None
+    mappings: str
+    file: str
+    sourcesContent: list[str]
+    sourceRoot: str
+
+
+class SourceMapStatistic(TypedDict):
+    includesFiles: list[str]
+    filesStatistics: dict[str, int]
+    sourceMapPath: str
+
+
+class DecodeResult(NamedTuple):
+    files: dict[str, str]
+    sourceMapStatistic: SourceMapStatistic
+
+
+def remove_prefix(line: str) -> str:
+    prefixes = ["webpack://"]
+    for prefix in prefixes:
+        line = line.removeprefix(prefix)
+
+    return line
+
+
+def parse_content(content: str) -> SourceMap:
+    sm: dict[str, Any] = {
+        "names": None,
+    }
+    sm |= json.loads(content)
+
+    return SourceMap(**sm)
+
+
+def parse_suffix(file_path: str) -> str:
+    path = Path(file_path)
+    suffix = path.suffix
+
+    return suffix.split("?")[0]
+
+
+def decode(content: str) -> Error | DecodeResult:
+    sm = parse_content(content)
+
+    if sm.version != 3:
+        return error(f"Source Maps версии {sm.version} не поддерживается")
+
+    files: dict[str, str] = {}
+    suffix_stats = MapCounter()
+
+    for idx, file_path in enumerate(sm.sources):
+        file_path = remove_prefix(file_path)
+        file_content = sm.sourcesContent[idx]
+
+        suffix_stats.increment(parse_suffix(file_path))
+        files[file_path] = file_content
+
+    sm_stat = SourceMapStatistic(
+        includesFiles=sm.sources,
+        filesStatistics=suffix_stats.total,
+        sourceMapPath=sm.file,
+    )
+
+    return DecodeResult(files, sm_stat)

common/source_maps.py

@@ -0,0 +1,161 @@
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, TypedDict
+
+from common import source_maps
+from common.error import Error
+from common.safe_path import safe_path_join
+
+FORBIDDEN_SYMBOL_LIST = ["|", "{", "}", "$", "^"]
+RENAMED_SYMBOL_LIST = [" "]
+
+
+class DecoderStatistic(TypedDict):
+    forbiddenPaths: list[str]
+    renamedPaths: dict[str, str]
+    deduplicated: dict[str, str]
+
+
+def check_in_forbidden_symbols(file_path: str) -> bool:
+    for forbidden_symbol in FORBIDDEN_SYMBOL_LIST:
+        if forbidden_symbol in file_path:
+            return True
+
+    return False
+
+
+def remove_renamed_symbols(file_path: str) -> str:
+    for symbol in RENAMED_SYMBOL_LIST:
+        file_path = file_path.replace(symbol, "_")
+
+    return file_path
+
+
+def get_saved_folder(map_file: Path) -> str:
+    suffixes = [".map", ".js"]
+
+    file_name = map_file.name
+    for suffix in suffixes:
+        file_name = file_name.removesuffix(suffix)
+
+    assert not file_name.endswith(".js") and not file_name.endswith(".map"), "Не правильно удалились расширения"
+    return file_name
+
+
+def save_statistic_file(output_file_folder: Path, statistic: Any) -> None:
+    output_file_folder.write_text(json.dumps(statistic, indent=2))
+
+
+def save_decode_result(output_folder: Path, bundle_name: str, decode_result: source_maps.DecodeResult) -> None:
+    folder_path = output_folder / bundle_name
+    if not folder_path.exists():
+        folder_path.mkdir()
+
+    files_folder_path = folder_path / "files"
+    if not files_folder_path.exists():
+        files_folder_path.mkdir()
+
+    forbidden_paths: list[str] = []
+    renamed_paths: dict[str, str] = {}
+    deduplicated: dict[str, str] = {}
+
+    # Папка в который лежит бандл, относительной данной папки, мы и будет сохранять файлы
+    relative_folder_in_sm = Path(decode_result.sourceMapStatistic["sourceMapPath"]).parent
+    for file_path, file_content in decode_result.files.items():
+        if check_in_forbidden_symbols(file_path):
+            forbidden_paths.append(file_path)
+            print("[INFO]", f"Файл '{file_path}' был убран для сохранения")
+            continue
+
+        if (new_value := remove_renamed_symbols(file_path)) != file_path:
+            renamed_paths[file_path] = new_value
+            print("[INFO]", f"Файл '{file_path}' был переименован")
+            file_path = new_value
+
+        # Убираем первый '/', что-бы не попасть в корень диска
+        file_path = file_path.removeprefix("/")
+
+        # Путь восстанавливаемого файла в Sources Map
+        file_path_in_sm = relative_folder_in_sm / file_path
+
+        saved_file_path = safe_path_join(files_folder_path, file_path_in_sm)
+        if not saved_file_path.parent.exists():
+            saved_file_path.parent.mkdir(parents=True)
+
+        if saved_file_path.exists():
+            old_file_path = str(saved_file_path)
+            print("[INFO]", f"Задублирование файла '{saved_file_path}'")
+
+            saved_file_path = Path(f"{saved_file_path}?dep2")
+            deduplicated[old_file_path] = str(saved_file_path)
+
+        saved_file_path.write_text(file_content)
+
+    decoder_statistic = DecoderStatistic(
+        forbiddenPaths=forbidden_paths,
+        renamedPaths=renamed_paths,
+        deduplicated=deduplicated,
+    )
+
+    save_statistic_file(folder_path / "statistic.json", decode_result.sourceMapStatistic)
+    save_statistic_file(folder_path / "decoder.json", decoder_statistic)
+
+
+def get_sources_maps_files(input_path: Path) -> list[Path]:
+    if not input_path.exists():
+        exit(f"Файл или папки '{input_path}' не существует")
+
+    if input_path.is_dir():
+        return [file for file in input_path.glob("*.map") if file.is_file()]
+
+    if input_path.is_file():
+        return [input_path]
+
+    exit(f"Невозможно определить тип пути: {input_path}")
+
+
+def decoder(input_path: str, output_folder: str) -> None:
+    output_path = Path(output_folder)
+    if output_path.exists():
+        print("[WARNING]", f"Папка '{output_folder}', уже существует, возможны ошибки при работе программы")
+    else:
+        output_path.mkdir(parents=True)
+
+    sm_files = get_sources_maps_files(Path(input_path))
+    for sm_file in sm_files:
+        result = source_maps.decode(sm_file.read_text(encoding="utf-8"))
+        if isinstance(result, Error):
+            print("[ERROR]", f"Произошла ошибка при декодировании файла '{sm_file}': {result.message}")
+            continue
+
+        bundle_name = get_saved_folder(sm_file)
+        save_decode_result(output_path, bundle_name, result)
+
+
+def main(argv: list[str]) -> None:
+    parser = argparse.ArgumentParser(description="JavaScript Source Maps Decoder")
+    parser.add_argument(
+        "-I",
+        "--input",
+        dest="input_path",
+        type=str,
+        required=True,
+        help="Путь до файла или директории c Source Map",
+    )
+    parser.add_argument(
+        "-O",
+        "--output",
+        dest="output_folder",
+        type=str,
+        default="output",
+        help="Путь до папки для вывода",
+    )
+
+    args = parser.parse_args(argv)
+    decoder(**vars(args))
+
+
+if __name__ == "__main__":
+    main(sys.argv[1::])