@pnpm/exe 11.10.0 → 12.0.0-alpha.1

package/dist/node_modules/node-gyp/gyp/pylib/gyp/ninja_syntax.py

@@ -1,174 +0,0 @@
-# This file comes from
-#   https://github.com/martine/ninja/blob/master/misc/ninja_syntax.py
-# Do not edit!  Edit the upstream one instead.
-
-"""Python module for generating .ninja files.
-
-Note that this is emphatically not a required piece of Ninja; it's
-just a helpful utility for build-file-generation systems that already
-use Python.
-"""
-
-import textwrap
-
-
-def escape_path(word):
-    return word.replace("$ ", "$$ ").replace(" ", "$ ").replace(":", "$:")
-
-
-class Writer:
-    def __init__(self, output, width=78):
-        self.output = output
-        self.width = width
-
-    def newline(self):
-        self.output.write("\n")
-
-    def comment(self, text):
-        for line in textwrap.wrap(text, self.width - 2):
-            self.output.write("# " + line + "\n")
-
-    def variable(self, key, value, indent=0):
-        if value is None:
-            return
-        if isinstance(value, list):
-            value = " ".join(filter(None, value))  # Filter out empty strings.
-        self._line(f"{key} = {value}", indent)
-
-    def pool(self, name, depth):
-        self._line("pool %s" % name)
-        self.variable("depth", depth, indent=1)
-
-    def rule(
-        self,
-        name,
-        command,
-        description=None,
-        depfile=None,
-        generator=False,
-        pool=None,
-        restat=False,
-        rspfile=None,
-        rspfile_content=None,
-        deps=None,
-    ):
-        self._line("rule %s" % name)
-        self.variable("command", command, indent=1)
-        if description:
-            self.variable("description", description, indent=1)
-        if depfile:
-            self.variable("depfile", depfile, indent=1)
-        if generator:
-            self.variable("generator", "1", indent=1)
-        if pool:
-            self.variable("pool", pool, indent=1)
-        if restat:
-            self.variable("restat", "1", indent=1)
-        if rspfile:
-            self.variable("rspfile", rspfile, indent=1)
-        if rspfile_content:
-            self.variable("rspfile_content", rspfile_content, indent=1)
-        if deps:
-            self.variable("deps", deps, indent=1)
-
-    def build(
-        self, outputs, rule, inputs=None, implicit=None, order_only=None, variables=None
-    ):
-        outputs = self._as_list(outputs)
-        all_inputs = self._as_list(inputs)[:]
-        out_outputs = list(map(escape_path, outputs))
-        all_inputs = list(map(escape_path, all_inputs))
-
-        if implicit:
-            implicit = map(escape_path, self._as_list(implicit))
-            all_inputs.append("|")
-            all_inputs.extend(implicit)
-        if order_only:
-            order_only = map(escape_path, self._as_list(order_only))
-            all_inputs.append("||")
-            all_inputs.extend(order_only)
-
-        self._line(
-            "build {}: {}".format(" ".join(out_outputs), " ".join([rule] + all_inputs))
-        )
-
-        if variables:
-            if isinstance(variables, dict):
-                iterator = iter(variables.items())
-            else:
-                iterator = iter(variables)
-
-            for key, val in iterator:
-                self.variable(key, val, indent=1)
-
-        return outputs
-
-    def include(self, path):
-        self._line("include %s" % path)
-
-    def subninja(self, path):
-        self._line("subninja %s" % path)
-
-    def default(self, paths):
-        self._line("default %s" % " ".join(self._as_list(paths)))
-
-    def _count_dollars_before_index(self, s, i):
-        """Returns the number of '$' characters right in front of s[i]."""
-        dollar_count = 0
-        dollar_index = i - 1
-        while dollar_index > 0 and s[dollar_index] == "$":
-            dollar_count += 1
-            dollar_index -= 1
-        return dollar_count
-
-    def _line(self, text, indent=0):
-        """Write 'text' word-wrapped at self.width characters."""
-        leading_space = "  " * indent
-        while len(leading_space) + len(text) > self.width:
-            # The text is too wide; wrap if possible.
-
-            # Find the rightmost space that would obey our width constraint and
-            # that's not an escaped space.
-            available_space = self.width - len(leading_space) - len(" $")
-            space = available_space
-            while True:
-                space = text.rfind(" ", 0, space)
-                if space < 0 or self._count_dollars_before_index(text, space) % 2 == 0:
-                    break
-
-            if space < 0:
-                # No such space; just use the first unescaped space we can find.
-                space = available_space - 1
-                while True:
-                    space = text.find(" ", space + 1)
-                    if (
-                        space < 0
-                        or self._count_dollars_before_index(text, space) % 2 == 0
-                    ):
-                        break
-            if space < 0:
-                # Give up on breaking.
-                break
-
-            self.output.write(leading_space + text[0:space] + " $\n")
-            text = text[space + 1 :]
-
-            # Subsequent lines are continuations, so indent them.
-            leading_space = "  " * (indent + 2)
-
-        self.output.write(leading_space + text + "\n")
-
-    def _as_list(self, input):
-        if input is None:
-            return []
-        if isinstance(input, list):
-            return input
-        return [input]
-
-
-def escape(string):
-    """Escape a string such that it can be embedded into a Ninja file without
-    further interpretation."""
-    assert "\n" not in string, "Ninja syntax does not allow newlines"
-    # We only have one special metacharacter: '$'.
-    return string.replace("$", "$$")

package/dist/node_modules/node-gyp/gyp/pylib/gyp/simple_copy.py

@@ -1,61 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""A clone of the default copy.deepcopy that doesn't handle cyclic
-structures or complex types except for dicts and lists. This is
-because gyp copies so large structure that small copy overhead ends up
-taking seconds in a project the size of Chromium."""
-
-
-class Error(Exception):
-    pass
-
-
-__all__ = ["Error", "deepcopy"]
-
-
-def deepcopy(x):
-    """Deep copy operation on gyp objects such as strings, ints, dicts
-    and lists. More than twice as fast as copy.deepcopy but much less
-    generic."""
-
-    try:
-        return _deepcopy_dispatch[type(x)](x)
-    except KeyError:
-        raise Error(
-            f"Unsupported type {type(x)} for deepcopy. Use copy.deepcopy "
-            + "or expand simple_copy support."
-        )
-
-
-_deepcopy_dispatch = d = {}
-
-
-def _deepcopy_atomic(x):
-    return x
-
-
-types = bool, float, int, str, type, type(None)
-
-for x in types:
-    d[x] = _deepcopy_atomic
-
-
-def _deepcopy_list(x):
-    return [deepcopy(a) for a in x]
-
-
-d[list] = _deepcopy_list
-
-
-def _deepcopy_dict(x):
-    y = {}
-    for key, value in x.items():
-        y[deepcopy(key)] = deepcopy(value)
-    return y
-
-
-d[dict] = _deepcopy_dict
-
-del d

package/dist/node_modules/node-gyp/gyp/pylib/gyp/win_tool.py

@@ -1,371 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Utility functions for Windows builds.
-
-These functions are executed via gyp-win-tool when using the ninja generator.
-"""
-
-import os
-import re
-import shutil
-import stat
-import string
-import subprocess
-import sys
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-
-# A regex matching an argument corresponding to the output filename passed to
-# link.exe.
-_LINK_EXE_OUT_ARG = re.compile("/OUT:(?P<out>.+)$", re.IGNORECASE)
-
-
-def main(args):
-    executor = WinTool()
-    if (exit_code := executor.Dispatch(args)) is not None:
-        sys.exit(exit_code)
-
-
-class WinTool:
-    """This class performs all the Windows tooling steps. The methods can either
-    be executed directly, or dispatched from an argument list."""
-
-    def _UseSeparateMspdbsrv(self, env, args):
-        """Allows to use a unique instance of mspdbsrv.exe per linker instead of a
-        shared one."""
-        if len(args) < 1:
-            raise Exception("Not enough arguments")
-
-        if args[0] != "link.exe":
-            return
-
-        # Use the output filename passed to the linker to generate an endpoint name
-        # for mspdbsrv.exe.
-        endpoint_name = None
-        for arg in args:
-            m = _LINK_EXE_OUT_ARG.match(arg)
-            if m:
-                endpoint_name = re.sub(
-                    r"\W+", "", "%s_%d" % (m.group("out"), os.getpid())
-                )
-                break
-
-        if endpoint_name is None:
-            return
-
-        # Adds the appropriate environment variable. This will be read by link.exe
-        # to know which instance of mspdbsrv.exe it should connect to (if it's
-        # not set then the default endpoint is used).
-        env["_MSPDBSRV_ENDPOINT_"] = endpoint_name
-
-    def Dispatch(self, args):
-        """Dispatches a string command to a method."""
-        if len(args) < 1:
-            raise Exception("Not enough arguments")
-
-        method = "Exec%s" % self._CommandifyName(args[0])
-        return getattr(self, method)(*args[1:])
-
-    def _CommandifyName(self, name_string):
-        """Transforms a tool name like recursive-mirror to RecursiveMirror."""
-        return name_string.title().replace("-", "")
-
-    def _GetEnv(self, arch):
-        """Gets the saved environment from a file for a given architecture."""
-        # The environment is saved as an "environment block" (see CreateProcess
-        # and msvs_emulation for details). We convert to a dict here.
-        # Drop last 2 NULs, one for list terminator, one for trailing vs. separator.
-        pairs = open(arch).read()[:-2].split("\0")
-        kvs = [item.split("=", 1) for item in pairs]
-        return dict(kvs)
-
-    def ExecStamp(self, path):
-        """Simple stamp command."""
-        open(path, "w").close()
-
-    def ExecRecursiveMirror(self, source, dest):
-        """Emulation of rm -rf out && cp -af in out."""
-        if os.path.exists(dest):
-            if os.path.isdir(dest):
-
-                def _on_error(fn, path, excinfo):
-                    # The operation failed, possibly because the file is set to
-                    # read-only. If that's why, make it writable and try the op again.
-                    if not os.access(path, os.W_OK):
-                        os.chmod(path, stat.S_IWRITE)
-                    fn(path)
-
-                shutil.rmtree(dest, onerror=_on_error)
-            else:
-                if not os.access(dest, os.W_OK):
-                    # Attempt to make the file writable before deleting it.
-                    os.chmod(dest, stat.S_IWRITE)
-                os.unlink(dest)
-
-        if os.path.isdir(source):
-            shutil.copytree(source, dest)
-        else:
-            shutil.copy2(source, dest)
-
-    def ExecLinkWrapper(self, arch, use_separate_mspdbsrv, *args):
-        """Filter diagnostic output from link that looks like:
-        '   Creating library ui.dll.lib and object ui.dll.exp'
-        This happens when there are exports from the dll or exe.
-        """
-        env = self._GetEnv(arch)
-        if use_separate_mspdbsrv == "True":
-            self._UseSeparateMspdbsrv(env, args)
-        if sys.platform == "win32":
-            args = list(args)  # *args is a tuple by default, which is read-only.
-            args[0] = args[0].replace("/", "\\")
-        # https://docs.python.org/2/library/subprocess.html:
-        # "On Unix with shell=True [...] if args is a sequence, the first item
-        # specifies the command string, and any additional items will be treated as
-        # additional arguments to the shell itself.  That is to say, Popen does the
-        # equivalent of:
-        #   Popen(['/bin/sh', '-c', args[0], args[1], ...])"
-        # For that reason, since going through the shell doesn't seem necessary on
-        # non-Windows don't do that there.
-        link = subprocess.Popen(
-            args,
-            shell=sys.platform == "win32",
-            env=env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        out = link.communicate()[0].decode("utf-8")
-        for line in out.splitlines():
-            if (
-                not line.startswith("   Creating library ")
-                and not line.startswith("Generating code")
-                and not line.startswith("Finished generating code")
-            ):
-                print(line)
-        return link.returncode
-
-    def ExecLinkWithManifests(
-        self,
-        arch,
-        embed_manifest,
-        out,
-        ldcmd,
-        resname,
-        mt,
-        rc,
-        intermediate_manifest,
-        *manifests,
-    ):
-        """A wrapper for handling creating a manifest resource and then executing
-        a link command."""
-        # The 'normal' way to do manifests is to have link generate a manifest
-        # based on gathering dependencies from the object files, then merge that
-        # manifest with other manifests supplied as sources, convert the merged
-        # manifest to a resource, and then *relink*, including the compiled
-        # version of the manifest resource. This breaks incremental linking, and
-        # is generally overly complicated. Instead, we merge all the manifests
-        # provided (along with one that includes what would normally be in the
-        # linker-generated one, see msvs_emulation.py), and include that into the
-        # first and only link. We still tell link to generate a manifest, but we
-        # only use that to assert that our simpler process did not miss anything.
-        variables = {
-            "python": sys.executable,
-            "arch": arch,
-            "out": out,
-            "ldcmd": ldcmd,
-            "resname": resname,
-            "mt": mt,
-            "rc": rc,
-            "intermediate_manifest": intermediate_manifest,
-            "manifests": " ".join(manifests),
-        }
-        add_to_ld = ""
-        if manifests:
-            subprocess.check_call(
-                "%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo "
-                "-manifest %(manifests)s -out:%(out)s.manifest" % variables
-            )
-            if embed_manifest == "True":
-                subprocess.check_call(
-                    "%(python)s gyp-win-tool manifest-to-rc %(arch)s %(out)s.manifest"
-                    " %(out)s.manifest.rc %(resname)s" % variables
-                )
-                subprocess.check_call(
-                    "%(python)s gyp-win-tool rc-wrapper %(arch)s %(rc)s "
-                    "%(out)s.manifest.rc" % variables
-                )
-                add_to_ld = " %(out)s.manifest.res" % variables
-        subprocess.check_call(ldcmd + add_to_ld)
-
-        # Run mt.exe on the theoretically complete manifest we generated, merging
-        # it with the one the linker generated to confirm that the linker
-        # generated one does not add anything. This is strictly unnecessary for
-        # correctness, it's only to verify that e.g. /MANIFESTDEPENDENCY was not
-        # used in a #pragma comment.
-        if manifests:
-            # Merge the intermediate one with ours to .assert.manifest, then check
-            # that .assert.manifest is identical to ours.
-            subprocess.check_call(
-                "%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo "
-                "-manifest %(out)s.manifest %(intermediate_manifest)s "
-                "-out:%(out)s.assert.manifest" % variables
-            )
-            assert_manifest = "%(out)s.assert.manifest" % variables
-            our_manifest = "%(out)s.manifest" % variables
-            # Load and normalize the manifests. mt.exe sometimes removes whitespace,
-            # and sometimes doesn't unfortunately.
-            with open(our_manifest) as our_f, open(assert_manifest) as assert_f:
-                translator = str.maketrans("", "", string.whitespace)
-                our_data = our_f.read().translate(translator)
-                assert_data = assert_f.read().translate(translator)
-            if our_data != assert_data:
-                os.unlink(out)
-
-                def dump(filename):
-                    print(filename, file=sys.stderr)
-                    print("-----", file=sys.stderr)
-                    with open(filename) as f:
-                        print(f.read(), file=sys.stderr)
-                        print("-----", file=sys.stderr)
-
-                dump(intermediate_manifest)
-                dump(our_manifest)
-                dump(assert_manifest)
-                sys.stderr.write(
-                    'Linker generated manifest "%s" added to final manifest "%s" '
-                    '(result in "%s"). '
-                    "Were /MANIFEST switches used in #pragma statements? "
-                    % (intermediate_manifest, our_manifest, assert_manifest)
-                )
-                return 1
-
-    def ExecManifestWrapper(self, arch, *args):
-        """Run manifest tool with environment set. Strip out undesirable warning
-        (some XML blocks are recognized by the OS loader, but not the manifest
-        tool)."""
-        env = self._GetEnv(arch)
-        popen = subprocess.Popen(
-            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-        )
-        out = popen.communicate()[0].decode("utf-8")
-        for line in out.splitlines():
-            if line and "manifest authoring warning 81010002" not in line:
-                print(line)
-        return popen.returncode
-
-    def ExecManifestToRc(self, arch, *args):
-        """Creates a resource file pointing a SxS assembly manifest.
-        |args| is tuple containing path to resource file, path to manifest file
-        and resource name which can be "1" (for executables) or "2" (for DLLs)."""
-        manifest_path, resource_path, resource_name = args
-        with open(resource_path, "w") as output:
-            output.write(
-                '#include <windows.h>\n%s RT_MANIFEST "%s"'
-                % (resource_name, os.path.abspath(manifest_path).replace("\\", "/"))
-            )
-
-    def ExecMidlWrapper(self, arch, outdir, tlb, h, dlldata, iid, proxy, idl, *flags):
-        """Filter noisy filenames output from MIDL compile step that isn't
-        quietable via command line flags.
-        """
-        args = (
-            ["midl", "/nologo"]
-            + list(flags)
-            + [
-                "/out",
-                outdir,
-                "/tlb",
-                tlb,
-                "/h",
-                h,
-                "/dlldata",
-                dlldata,
-                "/iid",
-                iid,
-                "/proxy",
-                proxy,
-                idl,
-            ]
-        )
-        env = self._GetEnv(arch)
-        popen = subprocess.Popen(
-            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-        )
-        out = popen.communicate()[0].decode("utf-8")
-        # Filter junk out of stdout, and write filtered versions. Output we want
-        # to filter is pairs of lines that look like this:
-        # Processing C:\Program Files (x86)\Microsoft SDKs\...\include\objidl.idl
-        # objidl.idl
-        lines = out.splitlines()
-        prefixes = ("Processing ", "64 bit Processing ")
-        processing = {os.path.basename(x) for x in lines if x.startswith(prefixes)}
-        for line in lines:
-            if not line.startswith(prefixes) and line not in processing:
-                print(line)
-        return popen.returncode
-
-    def ExecAsmWrapper(self, arch, *args):
-        """Filter logo banner from invocations of asm.exe."""
-        env = self._GetEnv(arch)
-        popen = subprocess.Popen(
-            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-        )
-        out = popen.communicate()[0].decode("utf-8")
-        for line in out.splitlines():
-            if (
-                not line.startswith("Copyright (C) Microsoft Corporation")
-                and not line.startswith("Microsoft (R) Macro Assembler")
-                and not line.startswith(" Assembling: ")
-                and line
-            ):
-                print(line)
-        return popen.returncode
-
-    def ExecRcWrapper(self, arch, *args):
-        """Filter logo banner from invocations of rc.exe. Older versions of RC
-        don't support the /nologo flag."""
-        env = self._GetEnv(arch)
-        popen = subprocess.Popen(
-            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-        )
-        out = popen.communicate()[0].decode("utf-8")
-        for line in out.splitlines():
-            if (
-                not line.startswith("Microsoft (R) Windows (R) Resource Compiler")
-                and not line.startswith("Copyright (C) Microsoft Corporation")
-                and line
-            ):
-                print(line)
-        return popen.returncode
-
-    def ExecActionWrapper(self, arch, rspfile, *dir):
-        """Runs an action command line from a response file using the environment
-        for |arch|. If |dir| is supplied, use that as the working directory."""
-        env = self._GetEnv(arch)
-        # TODO(scottmg): This is a temporary hack to get some specific variables
-        # through to actions that are set after gyp-time. http://crbug.com/333738.
-        for k, v in os.environ.items():
-            if k not in env:
-                env[k] = v
-        args = open(rspfile).read()
-        dir = dir[0] if dir else None
-        return subprocess.call(args, shell=True, env=env, cwd=dir)
-
-    def ExecClCompile(self, project_dir, selected_files):
-        """Executed by msvs-ninja projects when the 'ClCompile' target is used to
-        build selected C/C++ files."""
-        project_dir = os.path.relpath(project_dir, BASE_DIR)
-        selected_files = selected_files.split(";")
-        ninja_targets = [
-            os.path.join(project_dir, filename) + "^^" for filename in selected_files
-        ]
-        cmd = ["ninja.exe"]
-        cmd.extend(ninja_targets)
-        return subprocess.call(cmd, shell=True, cwd=BASE_DIR)
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))