File _service:tar_scm:chromium-103.0.5060.53-update-... of Package lld-15

File _service:tar_scm:chromium-103.0.5060.53-update-rjsmin-to-1.2.0.patch of Package lld-15 (Revision 04248f82f46d58b8c97cb8c08f274f0b)

Currently displaying revision 04248f82f46d58b8c97cb8c08f274f0b , Show latest

diff -up chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.c.12 chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.c
--- chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.c.12	2022-06-28 12:50:10.167324583 +0000
+++ chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.c	2021-11-14 19:50:55.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 - 2015
+ * Copyright 2011 - 2021
  * Andr\xe9 Malo or his licensors, as applicable
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,21 +18,21 @@
 #include "cext.h"
 EXT_INIT_FUNC;
 
-#define RJSMIN_DULL_BIT           (1 << 0)
-#define RJSMIN_PRE_REGEX_BIT      (1 << 1)
-#define RJSMIN_REGEX_DULL_BIT     (1 << 2)
-#define RJSMIN_REGEX_CC_DULL_BIT  (1 << 3)
-#define RJSMIN_ID_LIT_BIT         (1 << 4)
-#define RJSMIN_ID_LIT_O_BIT       (1 << 5)
-#define RJSMIN_ID_LIT_C_BIT       (1 << 6)
-#define RJSMIN_STRING_DULL_BIT    (1 << 7)
-#define RJSMIN_SPACE_BIT          (1 << 8)
-#define RJSMIN_POST_REGEX_OFF_BIT (1 << 9)
+#define RJSMIN_DULL_BIT           (1 <<  0)
+#define RJSMIN_PRE_REGEX_BIT      (1 <<  1)
+#define RJSMIN_REGEX_DULL_BIT     (1 <<  2)
+#define RJSMIN_REGEX_CC_DULL_BIT  (1 <<  3)
+#define RJSMIN_ID_LIT_BIT         (1 <<  4)
+#define RJSMIN_ID_LIT_O_BIT       (1 <<  5)
+#define RJSMIN_ID_LIT_C_BIT       (1 <<  6)
+#define RJSMIN_STRING_DULL_BIT    (1 <<  7)
+#define RJSMIN_SPACE_BIT          (1 <<  8)
+#define RJSMIN_POST_REGEX_OFF_BIT (1 <<  9)
+#define RJSMIN_A_Z_BIT            (1 << 10)
 
-#ifdef EXT3
-typedef Py_UNICODE rchar;
-#else
 typedef unsigned char rchar;
+#ifdef U
+#undef U
 #endif
 #define U(c) ((rchar)(c))
 
@@ -66,66 +66,120 @@ typedef unsigned char rchar;
 #define RJSMIN_IS_PRE_REGEX_1(c) ((U(c) <= 127) && \
     (rjsmin_charmask[U(c) & 0x7F] & RJSMIN_PRE_REGEX_BIT))
 
+#define RJSMIN_IS_A_Z(c) ((U(c) <= 127) && \
+    (rjsmin_charmask[U(c) & 0x7F] & RJSMIN_A_Z_BIT))
+
 
 static const unsigned short rjsmin_charmask[128] = {
-    396, 396, 396, 396, 396, 396, 396, 396,
-    396, 396,   2, 396, 396,   2, 396, 396,
-    396, 396, 396, 396, 396, 396, 396, 396,
-    396, 396, 396, 396, 396, 396, 396, 396,
-    396, 687, 588, 653, 765, 653, 143, 588,
-    687, 205, 653, 237, 143, 237, 141, 648,
-    765, 765, 765, 765, 765, 765, 765, 765,
-    765, 765, 143, 143, 653, 143, 653, 143,
-    653, 765, 765, 765, 765, 765, 765, 765,
-    765, 765, 765, 765, 765, 765, 765, 765,
-    765, 765, 765, 765, 765, 765, 765, 765,
-    765, 765, 765, 683, 513, 197, 653, 765,
-    653, 765, 765, 765, 765, 765, 765, 765,
-    765, 765, 765, 765, 765, 765, 765, 765,
-    765, 765, 765, 765, 765, 765, 765, 765,
-    765, 765, 765, 687, 143, 207, 653, 765
+     396,  396,  396,  396,  396,  396,  396,  396,
+     396,  396,    2,  396,  396,    2,  396,  396,
+     396,  396,  396,  396,  396,  396,  396,  396,
+     396,  396,  396,  396,  396,  396,  396,  396,
+     396,  687,  588,  653,  765,  653,  143,  588,
+     687,  205,  655,  239,  143,  239,  141,  648,
+     765,  765,  765,  765,  765,  765,  765,  765,
+     765,  765,  143,  143,  653,  143,  653,  143,
+     653,  765,  765,  765,  765,  765,  765,  765,
+     765,  765,  765,  765,  765,  765,  765,  765,
+     765,  765,  765,  765,  765,  765,  765,  765,
+     765,  765,  765,  683,  513,  197,  653,  765,
+     588, 1789, 1789, 1789, 1789, 1789, 1789, 1789,
+    1789, 1789, 1789, 1789, 1789, 1789, 1789, 1789,
+    1789, 1789, 1789, 1789, 1789, 1789, 1789, 1789,
+    1789, 1789, 1789,  687,  143,  207,  653,  765
 };
 
+
 static Py_ssize_t
 rjsmin(const rchar *source, rchar *target, Py_ssize_t length,
        int keep_bang_comments)
 {
-    const rchar *reset, *pcreset = NULL, *pctoken = NULL, *xtarget,
-                *sentinel = source + length;
-    rchar *tstart = target;
-    int post_regex = 0;
-    rchar c, quote, spaced = U(' ');
+    const rchar
+        *sentinel = source + length, /* never hit this pointer (source buf) */
+        *reset,          /* reset pointer (source buf) */
+        *pcreset = NULL, /* pre-comment reset pointer (source buf) */
+        *pctoken = NULL, /* pre-comment token pointer (target buf)
+                          * Pointing to before the last kept comment, if any */
+        *rsreset = NULL, /* regex-with-method reset pointer (source buf) */
+        *xtarget;        /* pre-regex-2 target pointer */
+
+    rchar *tstart = target, /* Target start pointer for reference */
+        *rtreset = NULL;    /* regex-with-method reset pointer (target buf) */
+
+    int rsdot,              /* seen dot after regex-with-method pattern? */
+        post_regex = 0;
+    rchar c, quote,
+        spaced = U(' ');    /* the last seen kind of space (nl taking prio),
+                             * init with ' ' */
 
+    /* main loop */
     while (source < sentinel) {
         c = *source++;
+
         if (RJSMIN_IS_DULL(c)) {
             if (post_regex) post_regex = 0;
             if (pctoken) pctoken = NULL;
             if (spaced == U('\n')) spaced = U(' ');
+            if (rsreset) {
+                /* both a-z and . are covered by "dull" */
+                if (!rsdot) {
+                    if (c != U('.')) {
+                        /* reset regex-with-method to the starting slash */
+                        source = rsreset;
+                        target = rtreset;
+                        rsreset = NULL;
+                        continue; /* main loop */
+                    }
+                    /* Found a dot after possible regex, looking for a-z now */
+                    rsdot = 1;
+                }
+                else if (!RJSMIN_IS_A_Z(c)) {
+                    /* reset regex-with-method to the starting slash */
+                    source = rsreset;
+                    target = rtreset;
+                    rsreset = NULL;
+                    continue; /* main loop */
+                }
+                else {
+                    /* Successfull finish the regex-with-method match */
+                    rsreset = NULL;
+                }
+            }
 
             *target++ = c;
-            continue;
+            continue; /* main loop */
         }
+
         switch (c) {
 
         /* String */
-        case U('\''): case U('"'):
+        case U('\''): case U('"'): case U('`'):
             if (post_regex) post_regex = 0;
             if (pctoken) pctoken = NULL;
             if (spaced == U('\n')) spaced = U(' ');
+            if (rsreset) {
+                /* reset regex-with-method to the starting slash */
+                source = rsreset;
+                target = rtreset;
+                rsreset = NULL;
+                continue; /* main loop */
+            }
 
             reset = source;
             *target++ = quote = c;
+
+            /* string loop */
             while (source < sentinel) {
                 c = *source++;
                 *target++ = c;
                 if (RJSMIN_IS_STRING_DULL(c))
-                    continue;
+                    continue; /* string loop */
+
                 switch (c) {
-                case U('\''): case U('"'):
+                case U('\''): case U('"'): case U('`'):
                     if (c == quote)
-                        goto cont;
-                    continue;
+                        goto cont; /* main loop */
+                    continue; /* string loop */
                 case U('\\'):
                     if (source < sentinel) {
                         c = *source++;
@@ -134,13 +188,18 @@ rjsmin(const rchar *source, rchar *targe
                             && *source == U('\n'))
                             *target++ = *source++;
                     }
-                    continue;
+                    continue; /* string loop */
+                case U('\r'): case U('\n'):
+                    if (quote != U('`'))
+                        break; /* string reset */
+                    continue; /* string loop */
                 }
-                break;
+                break; /* string reset */
             }
+            /* string reset */
             target -= source - reset;
             source = reset;
-            continue;
+            continue; /* main loop */
 
         /* Comment or Regex or something else entirely */
         case U('/'):
@@ -148,6 +207,13 @@ rjsmin(const rchar *source, rchar *targe
                 if (post_regex) post_regex = 0;
                 if (pctoken) pctoken = NULL;
                 if (spaced == U('\n')) spaced = U(' ');
+                if (rsreset) {
+                    /* reset regex-with-method to the starting slash */
+                    source = rsreset;
+                    target = rtreset;
+                    rsreset = NULL;
+                    continue; /* main loop */
+                }
 
                 *target++ = c;
             }
@@ -157,7 +223,19 @@ rjsmin(const rchar *source, rchar *targe
                 case U('*'): case U('/'):
                     goto skip_or_copy_ws;
 
+            /* Regex or slash */
                 default:
+                    if (rsreset) {
+                        /* reset regex-with-method to the starting slash */
+                        if (post_regex) post_regex = 0;
+                        if (pctoken) pctoken = NULL;
+                        if (spaced == U('\n')) spaced = U(' ');
+                        source = rsreset;
+                        target = rtreset;
+                        rsreset = NULL;
+                        continue; /* main loop */
+                    }
+
                     xtarget = NULL;
                     if (   target == tstart
                         || RJSMIN_IS_PRE_REGEX_1(*((pctoken ? pctoken : target)
@@ -176,99 +254,148 @@ rjsmin(const rchar *source, rchar *targe
                                 || !RJSMIN_IS_ID_LITERAL(*(xtarget - 7))
                             )
                         )) {
-
-            /* Regex */
+                        /* nothing to do here, continuing down below
+                         * We could unset rsreset here, but we know it already
+                         * is. */
+                        ;
+                    }
+                    else if (*((pctoken ? pctoken : target) - 1) == U(')')) {
+                        xtarget = NULL;
+                        rsreset = source;
+                        rtreset = target + 1;
+                        rsdot = 0;
+                    }
+                    else {
+                        /* Just a slash */
                         if (post_regex) post_regex = 0;
                         if (pctoken) pctoken = NULL;
+                        if (spaced == U('\n')) spaced = U(' ');
 
-                        reset = source;
-                        if (spaced == U('\n')) {
-                            spaced = U(' ');
-                            if (xtarget)
-                                *target++ = U('\n');
-                        }
+                        *target++ = c;
+                        continue; /* main loop */
+                    }
 
-                        *target++ = U('/');
-                        while (source < sentinel) {
-                            c = *source++;
-                            *target++ = c;
-                            if (RJSMIN_IS_REGEX_DULL(c))
-                                continue;
-                            switch (c) {
-                            case U('/'):
-                                post_regex = 1;
-                                goto cont;
-                            case U('\\'):
-                                if (source < sentinel) {
-                                    c = *source++;
-                                    *target++ = c;
-                                    if (c == U('\r') || c == U('\n'))
-                                        break;
-                                }
-                                continue;
-                            case U('['):
-                                while (source < sentinel) {
-                                    c = *source++;
-                                    *target++ = c;
-                                    if (RJSMIN_IS_REGEX_CC_DULL(c))
-                                        continue;
-                                    switch (c) {
-                                    case U('\\'):
-                                        if (source < sentinel) {
-                                            c = *source++;
-                                            *target++ = c;
-                                            if (c == U('\r') || c == U('\n'))
-                                                break;
-                                        }
-                                        continue;
-                                    case U(']'):
-                                        goto cont_regex;
+                    if (post_regex) post_regex = 0;
+                    if (pctoken) pctoken = NULL;
+
+                    reset = source;
+                    if (spaced == U('\n')) {
+                        spaced = U(' ');
+                        if (xtarget)
+                            *target++ = U('\n');
+                    }
+
+                    *target++ = U('/');
+
+                    /* regex loop */
+                    while (source < sentinel) {
+                        c = *source++;
+                        *target++ = c;
+
+                        if (RJSMIN_IS_REGEX_DULL(c))
+                            continue; /* regex loop */
+
+                        switch (c) {
+                        case U('/'):
+                            while (source < sentinel
+                                   && RJSMIN_IS_A_Z(*source))
+                                *target++ = *source++;
+                            post_regex = !rsreset;
+                            /* This check is supposed to make it faster.
+                             * It doesn't. It slows it down. I wonder why...
+                             */
+                            /*
+                             * if (!post_regex
+                             *     && source < sentinel - 1
+                             *     && *source == U('.')
+                             *     && RJSMIN_IS_A_Z(*(source + 1)))
+                             *     rsreset = NULL;
+                             */
+
+                            goto cont; /* main loop */
+
+                        case U('\\'):
+                            if (source < sentinel) {
+                                c = *source++;
+                                *target++ = c;
+                                if (c == U('\r') || c == U('\n'))
+                                    break; /* regex reset */
+                            }
+                            continue; /* regex loop */
+
+                        case U('['):
+                            /* regex CC loop */
+                            while (source < sentinel) {
+                                c = *source++;
+                                *target++ = c;
+
+                                if (RJSMIN_IS_REGEX_CC_DULL(c))
+                                    continue; /* regex CC loop */
+
+                                switch (c) {
+                                case U('\\'):
+                                    if (source < sentinel) {
+                                        c = *source++;
+                                        *target++ = c;
+                                        if (c == U('\r') || c == U('\n'))
+                                            break; /* regex reset */
                                     }
+                                    continue; /* regex CC loop */
+
+                                case U(']'):
+                                    goto cont_regex; /* regex loop */
                                 }
-                                break;
                             }
-                            break;
-                        cont_regex:
-                            continue;
+                            break; /* regex reset */
+
                         }
-                        target -= source - reset;
-                        source = reset;
-                    }
-                    else {
-            /* Just a slash */
-                        if (post_regex) post_regex = 0;
-                        if (pctoken) pctoken = NULL;
-                        if (spaced == U('\n')) spaced = U(' ');
+                        break; /* regex reset */
 
-                        *target++ = c;
+                    cont_regex:
+                        continue; /* regex loop */
                     }
-                    continue;
+
+                    /* regex reset */
+                    target -= source - reset;
+                    source = reset;
+                    rsreset = NULL;
+                    continue; /* main loop */
                 }
             }
-            continue;
+            continue;  /* main loop */ /* LCOV_EXCL_LINE */
 
         /* Whitespace */
         default:
         skip_or_copy_ws:
+            /* remember if we've seen a newline, start with: no */
             quote = U(' ');
             --source;
+
+            /* space loop */
             while (source < sentinel) {
                 c = *source++;
                 if (RJSMIN_IS_SPACE(c))
-                    continue;
+                    continue; /* space loop */
+
                 switch (c) {
                 case U('\r'): case U('\n'):
                     quote = U('\n');
-                    continue;
+                    continue; /* space loop */
+
+                /* Can only be a comment at this point
+                 * (or ending prematurely) */
                 case U('/'):
                     if (source < sentinel) {
                         switch (*source) {
+
+                        /* multiline comment */
                         case U('*'):
                             reset = source++;
                             /* copy bang comment, if requested */
                             if (   keep_bang_comments && source < sentinel
                                 && *source == U('!')) {
                                 if (!pctoken) {
+                                    /* Backtracking if ending prematurely */
                                     pctoken = target;
                                     pcreset = reset;
                                 }
@@ -276,6 +403,8 @@ rjsmin(const rchar *source, rchar *targe
                                 *target++ = U('/');
                                 *target++ = U('*');
                                 *target++ = *source++;
+
+                                /* comment loop */
                                 while (source < sentinel) {
                                     c = *source++;
                                     *target++ = c;
@@ -283,20 +412,21 @@ rjsmin(const rchar *source, rchar *targe
                                         && *source == U('/')) {
                                         *target++ = *source++;
                                         reset = NULL;
-                                        break;
+                                        break; /* continue space loop */
                                     }
                                 }
                                 if (!reset)
-                                    continue;
+                                    continue; /* space loop */
 
+                                /* comment reset */
                                 target -= source - reset;
                                 source = reset;
                                 if (pcreset == reset) {
                                     pctoken = NULL;
                                     pcreset = NULL;
                                 }
-
                             }
+
                             /* strip regular comment */
                             else {
                                 while (source < sentinel) {
@@ -305,41 +435,52 @@ rjsmin(const rchar *source, rchar *targe
                                         && *source == U('/')) {
                                         ++source;
                                         reset = NULL;
-                                        break;
+                                        break; /* continue space loop */
                                     }
                                 }
                                 if (!reset)
-                                    continue;
+                                    continue; /* space loop */
+
+                                /* comment reset: fallback to slash */
                                 source = reset;
                                 *target++ = U('/');
                             }
-                            goto cont;
+                            goto cont; /* main loop */
+
+                        /* single line comment */
                         case U('/'):
                             ++source;
+
+                            /* single line comment loop */
                             while (source < sentinel) {
                                 c = *source++;
                                 switch (c) {
                                 case U('\n'):
-                                    break;
+                                    break; /* continue space loop */
+
                                 case U('\r'):
                                     if (source < sentinel
                                         && *source == U('\n'))
                                         ++source;
-                                    break;
+                                    break; /* continue space loop */
+
                                 default:
-                                    continue;
+                                    continue; /* single line comment loop */
                                 }
-                                break;
+                                break; /* continue space loop */
                             }
                             quote = U('\n');
-                            continue;
+                            continue; /* space loop */
                         }
                     }
                 }
+
+                /* No more spacy character found */
                 --source;
-                break;
+                break; /* end space loop */
             }
 
+            /* Copy a space if needed */
             if ((tstart < (pctoken ? pctoken : target) && source < sentinel)
                 && ((quote == U('\n')
                      && ((RJSMIN_IS_ID_LITERAL_CLOSE(*((pctoken ?
@@ -363,8 +504,9 @@ rjsmin(const rchar *source, rchar *targe
             pcreset = NULL;
             spaced = quote;
         }
+
     cont:
-        continue;
+        continue; /* main loop */
     }
     return (Py_ssize_t)(target - tstart);
 }
@@ -385,15 +527,15 @@ substitution regex.\n\
 :Note: This is a hand crafted C implementation built on the regex\n\
        semantics.\n\
 \n\
-:Parameters:\n\
-  `script` : ``str``\n\
+Parameters:\n\
+  script (str):\n\
     Script to minify\n\
 \n\
-  `keep_bang_comments` : ``bool``\n\
+  keep_bang_comments (bool):\n\
     Keep comments starting with an exclamation mark? (``/*!...*/``)\n\
 \n\
-:Return: Minified script\n\
-:Rtype: ``str``");
+Returns:\n\
+  str: Minified script");
 
 static PyObject *
 rjsmin_jsmin(PyObject *self, PyObject *args, PyObject *kwds)
@@ -404,15 +546,15 @@ rjsmin_jsmin(PyObject *self, PyObject *a
     int keep_bang_comments;
 #ifdef EXT2
     int uni;
-#define UOBJ "O"
 #endif
 #ifdef EXT3
-#define UOBJ "U"
+    int bytes;
+    rchar *bytescript;
 #endif
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, UOBJ "|O", kwlist,
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,
                                      &script, &keep_bang_comments_))
-        return NULL;
+        LCOV_EXCL_LINE_RETURN(NULL);
 
     if (!keep_bang_comments_)
         keep_bang_comments = 0;
@@ -425,28 +567,27 @@ rjsmin_jsmin(PyObject *self, PyObject *a
 #ifdef EXT2
     if (PyUnicode_Check(script)) {
         if (!(script = PyUnicode_AsUTF8String(script)))
-            return NULL;
+            LCOV_EXCL_LINE_RETURN(NULL);
         uni = 1;
     }
+    else if (!PyString_Check(script)) {
+        PyErr_SetString(PyExc_TypeError, "Unexpected type");
+        return NULL;
+    }
     else {
         if (!(script = PyObject_Str(script)))
-            return NULL;
+            LCOV_EXCL_LINE_RETURN(NULL);
         uni = 0;
     }
-#endif
-
-#ifdef EXT3
-    Py_INCREF(script);
-#define PyString_GET_SIZE PyUnicode_GET_SIZE
-#define PyString_AS_STRING PyUnicode_AS_UNICODE
-#define _PyString_Resize PyUnicode_Resize
-#define PyString_FromStringAndSize PyUnicode_FromUnicode
-#endif
-
     slength = PyString_GET_SIZE(script);
+
     if (!(result = PyString_FromStringAndSize(NULL, slength))) {
+        LCOV_EXCL_START
+
         Py_DECREF(script);
         return NULL;
+
+        LCOV_EXCL_STOP
     }
     Py_BEGIN_ALLOW_THREADS
     length = rjsmin((rchar *)PyString_AS_STRING(script),
@@ -456,30 +597,97 @@ rjsmin_jsmin(PyObject *self, PyObject *a
 
     Py_DECREF(script);
     if (length < 0) {
+        LCOV_EXCL_START
+
         Py_DECREF(result);
         return NULL;
+
+        LCOV_EXCL_STOP
     }
     if (length != slength && _PyString_Resize(&result, length) == -1)
-        return NULL;
+        LCOV_EXCL_LINE_RETURN(NULL);
 
-#ifdef EXT2
     if (uni) {
         script = PyUnicode_DecodeUTF8(PyString_AS_STRING(result),
                                       PyString_GET_SIZE(result), "strict");
         Py_DECREF(result);
-        if (!script)
-            return NULL;
-        result = script;
+        return script;
     }
-#endif
+
     return result;
+
+#else  /* EXT3 */
+
+    if (PyUnicode_Check(script)) {
+        bytes = 0;
+        script = PyUnicode_AsUTF8String(script);
+        bytescript = (rchar *)PyBytes_AS_STRING(script);
+        slength = PyBytes_GET_SIZE(script);
+    }
+    else if (PyBytes_Check(script)) {
+        bytes = 1;
+        Py_INCREF(script);
+        bytescript = (rchar *)PyBytes_AS_STRING(script);
+        slength = PyBytes_GET_SIZE(script);
+    }
+    else if (PyByteArray_Check(script)) {
+        bytes = 2;
+        Py_INCREF(script);
+        bytescript = (rchar *)PyByteArray_AS_STRING(script);
+        slength = PyByteArray_GET_SIZE(script);
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError, "Unexpected type");
+        return NULL;
+    }
+
+    if (!(result = PyBytes_FromStringAndSize(NULL, slength))) {
+        LCOV_EXCL_START
+
+        Py_DECREF(script);
+        return NULL;
+
+        LCOV_EXCL_STOP
+    }
+    Py_BEGIN_ALLOW_THREADS
+    length = rjsmin(bytescript, (rchar *)PyBytes_AS_STRING(result),
+                    slength, keep_bang_comments);
+    Py_END_ALLOW_THREADS
+
+    Py_DECREF(script);
+    if (length < 0) {
+        LCOV_EXCL_START
+
+        Py_DECREF(result);
+        return NULL;
+
+        LCOV_EXCL_STOP
+    }
+
+    if (!bytes) {
+        script = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(result), length,
+                                      "strict");
+        Py_DECREF(result);
+        return script;
+    }
+    if (bytes == 1) {
+        if (length != slength) {
+            _PyBytes_Resize(&result, length);
+        }
+        return result;
+    }
+    /* bytes == 2: bytearray */
+    script = PyByteArray_FromStringAndSize(PyBytes_AS_STRING(result), length);
+    Py_DECREF(result);
+    return script;
+#endif
 }
 
 /* ------------------------ BEGIN MODULE DEFINITION ------------------------ */
 
 EXT_METHODS = {
     {"jsmin",
-        (PyCFunction)rjsmin_jsmin, METH_VARARGS | METH_KEYWORDS,
+        EXT_CFUNC(rjsmin_jsmin), METH_VARARGS | METH_KEYWORDS,
         rjsmin_jsmin__doc__},
 
     {NULL}  /* Sentinel */
@@ -499,10 +707,10 @@ EXT_INIT_FUNC {
 
     /* Create the module and populate stuff */
     if (!(m = EXT_CREATE(&EXT_DEFINE_VAR)))
-        EXT_INIT_ERROR(NULL);
+        EXT_INIT_ERROR(LCOV_EXCL_LINE(NULL));
 
     EXT_ADD_UNICODE(m, "__author__", "Andr\xe9 Malo", "latin-1");
-    EXT_ADD_STRING(m, "__docformat__", "restructuredtext en");
+    EXT_ADD_STRING(m, "__version__", STRINGIFY(EXT_VERSION));
 
     EXT_INIT_RETURN(m);
 }
diff -up chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.py.12 chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.py
--- chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.py.12	2022-07-01 20:33:39.317727375 +0000
+++ chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/rjsmin.py	2021-11-14 20:24:16.000000000 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: ascii -*-
-r"""
+u"""
 =====================
  Javascript Minifier
 =====================
@@ -11,7 +11,7 @@ The minifier is based on the semantics o
 
 :Copyright:
 
- Copyright 2011 - 2015
+ Copyright 2011 - 2021
  Andr\xe9 Malo or his licensors, as applicable
 
 :License:
@@ -39,9 +39,11 @@ same results as the original ``jsmin.c``
 - Newline characters are not allowed inside string and regex literals, except
   for line continuations in string literals (ECMA-5).
 - "return /regex/" is recognized correctly.
+- More characters are allowed before regexes.
 - Line terminators after regex literals are handled more sensibly
 - "+ +" and "- -" sequences are not collapsed to '++' or '--'
 - Newlines before ! operators are removed more sensibly
+- (Unnested) template literals are supported (ECMA-6)
 - Comments starting with an exclamation mark (``!``) can be kept optionally
 - rJSmin does not handle streams, but only complete strings. (However, the
   module provides a "streamy" interface).
@@ -56,20 +58,17 @@ file for details.
 
 rjsmin.c is a reimplementation of rjsmin.py in C and speeds it up even more.
 
-Both python 2 and python 3 are supported.
+Supported python versions are 2.7 and 3.6+.
 
 .. _jsmin.c by Douglas Crockford:
    http://www.crockford.com/javascript/jsmin.c
 """
-if __doc__:
-    # pylint: disable = redefined-builtin
-    __doc__ = __doc__.encode('ascii').decode('unicode_escape')
-__author__ = r"Andr\xe9 Malo".encode('ascii').decode('unicode_escape')
-__docformat__ = "restructuredtext en"
+__author__ = u"Andr\xe9 Malo"
 __license__ = "Apache License, Version 2.0"
-__version__ = '1.0.12'
+__version__ = '1.2.0'
 __all__ = ['jsmin']
 
+import functools as _ft
 import re as _re
 
 
@@ -80,13 +79,13 @@ def _make_jsmin(python_only=False):
     .. _jsmin.c by Douglas Crockford:
        http://www.crockford.com/javascript/jsmin.c
 
-    :Parameters:
-      `python_only` : ``bool``
+    Parameters:
+      python_only (bool):
         Use only the python variant. If true, the c extension is not even
         tried to be loaded.
 
-    :Return: Minifier
-    :Rtype: ``callable``
+    Returns:
+      callable: Minifier
     """
     # pylint: disable = unused-variable
     # pylint: disable = too-many-locals
@@ -97,7 +96,10 @@ def _make_jsmin(python_only=False):
         except ImportError:
             pass
         else:
-            return _rjsmin.jsmin
+            # Ensure that the C version is in sync
+            # https://github.com/ndparker/rjsmin/issues/11
+            if getattr(_rjsmin, '__version__', None) == __version__:
+                return _rjsmin.jsmin
     try:
         xrange
     except NameError:
@@ -110,15 +112,16 @@ def _make_jsmin(python_only=False):
     space_comment_nobang = r'(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*\*+)*/)'
     bang_comment = r'(?:/\*![^*]*\*+(?:[^/*][^*]*\*+)*/)'
 
-    string1 = \
-        r'(?:\047[^\047\\\r\n]*(?:\\(?:[^\r\n]|\r?\n|\r)[^\047\\\r\n]*)*\047)'
+    string1 = r"(?:'[^'\\\r\n]*(?:\\(?:[^\r\n]|\r?\n|\r)[^'\\\r\n]*)*')"
+    string1 = string1.replace("'", r'\047')  # portability
     string2 = r'(?:"[^"\\\r\n]*(?:\\(?:[^\r\n]|\r?\n|\r)[^"\\\r\n]*)*")'
-    string3 = r'(?:`(?:[^`\\]|\\.)*`)'
+    string3 = r'(?:`[^`\\]*(?:\\(?:[^\r\n]|\r?\n|\r)[^`\\]*)*`)'
+    string3 = string3.replace('`', r'\140')  # portability
     strings = r'(?:%s|%s|%s)' % (string1, string2, string3)
 
     charclass = r'(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\])'
     nospecial = r'[^/\\\[\r\n]'
-    regex = r'(?:/(?![\r\n/*])%s*(?:(?:\\[^\r\n]|%s)%s*)*/)' % (
+    regex = r'(?:/(?![\r\n/*])%s*(?:(?:\\[^\r\n]|%s)%s*)*/[a-z]*)' % (
         nospecial, charclass, nospecial
     )
     space = r'(?:%s|%s)' % (space_chars, space_comment)
@@ -154,7 +157,7 @@ def _make_jsmin(python_only=False):
             ) for first, last in result])  # noqa
 
         return _re.sub(
-            r'([\000-\040\047])',  # \047 for better portability
+            r"([\000-\040'`])",  # ' and ` for better portability
             lambda m: '\\%03o' % ord(m.group(1)), (
                 sequentize(result)
                 .replace('\\', '\\\\')
@@ -180,42 +183,48 @@ def _make_jsmin(python_only=False):
         return r'[%s]' % fix_charclass(result)
 
     not_id_literal = not_id_literal_(r'[a-zA-Z0-9_$]')
-    preregex1 = r'[(,=:\[!&|?{};\r\n]'
+    preregex1 = r'[(,=:\[!&|?{};\r\n+*-]'
     preregex2 = r'%(not_id_literal)sreturn' % locals()
 
     id_literal = id_literal_(r'[a-zA-Z0-9_$]')
     id_literal_open = id_literal_(r'[a-zA-Z0-9_${\[(!+-]')
-    id_literal_close = id_literal_(r'[a-zA-Z0-9_$}\])"\047+-]')
+    id_literal_close = id_literal_(r'[a-zA-Z0-9_$}\])"\047\140+-]')
     post_regex_off = id_literal_(r'[^\000-\040}\])?:|,;.&=+-]')
 
-    dull = r'[^\047"`/\000-\040]'
+    dull = r'[^\047"\140/\000-\040]'
 
     space_sub_simple = _re.compile((
-        # noqa pylint: disable = bad-continuation
+        # noqa pylint: disable = bad-option-value, bad-continuation
 
         r'(%(dull)s+)'                                         # 0
         r'|(%(strings)s%(dull)s*)'                             # 1
-        r'|(?<=%(preregex1)s)'
+        r'|(?<=[)])'
             r'%(space)s*(?:%(newline)s%(space)s*)*'
             r'(%(regex)s)'                                     # 2
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 3
+            r'(?=%(space)s*(?:%(newline)s%(space)s*)*'
+                r'\.'
+                r'%(space)s*(?:%(newline)s%(space)s*)*[a-z])'
+        r'|(?<=%(preregex1)s)'
+            r'%(space)s*(?:%(newline)s%(space)s*)*'
+            r'(%(regex)s)'                                     # 3
+            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 4
                 r'(?=%(post_regex_off)s))?'
         r'|(?<=%(preregex2)s)'
-            r'%(space)s*(?:(%(newline)s)%(space)s*)*'          # 4
-            r'(%(regex)s)'                                     # 5
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 6
+            r'%(space)s*(?:(%(newline)s)%(space)s*)*'          # 5
+            r'(%(regex)s)'                                     # 6
+            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 7
                 r'(?=%(post_regex_off)s))?'
         r'|(?<=%(id_literal_close)s)'
-            r'%(space)s*(?:(%(newline)s)%(space)s*)+'          # 7
+            r'%(space)s*(?:(%(newline)s)%(space)s*)+'          # 8
             r'(?=%(id_literal_open)s)'
-        r'|(?<=%(id_literal)s)(%(space)s)+(?=%(id_literal)s)'  # 8
-        r'|(?<=\+)(%(space)s)+(?=\+)'                          # 9
-        r'|(?<=-)(%(space)s)+(?=-)'                            # 10
+        r'|(?<=%(id_literal)s)(%(space)s)+(?=%(id_literal)s)'  # 9
+        r'|(?<=\+)(%(space)s)+(?=\+)'                          # 10
+        r'|(?<=-)(%(space)s)+(?=-)'                            # 11
         r'|%(space)s+'
         r'|(?:%(newline)s%(space)s*)+'
     ) % locals()).sub
 
-    # print space_sub_simple.__self__.pattern
+    # print(space_sub_simple.__self__.pattern)
 
     def space_subber_simple(match):
         """ Substitution callback """
@@ -227,48 +236,56 @@ def _make_jsmin(python_only=False):
         elif groups[1]:
             return groups[1]
         elif groups[2]:
-            if groups[3]:
-                return groups[2] + '\n'
             return groups[2]
-        elif groups[5]:
+        elif groups[3]:
+            if groups[4]:
+                return groups[3] + '\n'
+            return groups[3]
+        elif groups[6]:
             return "%s%s%s" % (
-                groups[4] and '\n' or '',
-                groups[5],
-                groups[6] and '\n' or '',
+                groups[5] and '\n' or '',
+                groups[6],
+                groups[7] and '\n' or '',
             )
-        elif groups[7]:
+        elif groups[8]:
             return '\n'
-        elif groups[8] or groups[9] or groups[10]:
+        elif groups[9] or groups[10] or groups[11]:
             return ' '
         else:
             return ''
 
     space_sub_banged = _re.compile((
-        # noqa pylint: disable = bad-continuation
+        # noqa pylint: disable = bad-option-value, bad-continuation
 
         r'(%(dull)s+)'                                         # 0
         r'|(%(strings)s%(dull)s*)'                             # 1
-        r'|(?<=%(preregex1)s)'
+        r'|(?<=[)])'
             r'(%(space)s*(?:%(newline)s%(space)s*)*)'          # 2
             r'(%(regex)s)'                                     # 3
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 4
+            r'(?=%(space)s*(?:%(newline)s%(space)s*)*'
+                r'\.'
+                r'%(space)s*(?:%(newline)s%(space)s*)*[a-z])'
+        r'|(?<=%(preregex1)s)'
+            r'(%(space)s*(?:%(newline)s%(space)s*)*)'          # 4
+            r'(%(regex)s)'                                     # 5
+            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 6
                 r'(?=%(post_regex_off)s))?'
         r'|(?<=%(preregex2)s)'
-            r'(%(space)s*(?:(%(newline)s)%(space)s*)*)'        # 5, 6
-            r'(%(regex)s)'                                     # 7
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 8
+            r'(%(space)s*(?:(%(newline)s)%(space)s*)*)'        # 7, 8
+            r'(%(regex)s)'                                     # 9
+            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 10
                 r'(?=%(post_regex_off)s))?'
         r'|(?<=%(id_literal_close)s)'
-            r'(%(space)s*(?:%(newline)s%(space)s*)+)'          # 9
+            r'(%(space)s*(?:%(newline)s%(space)s*)+)'          # 11
             r'(?=%(id_literal_open)s)'
-        r'|(?<=%(id_literal)s)(%(space)s+)(?=%(id_literal)s)'  # 10
-        r'|(?<=\+)(%(space)s+)(?=\+)'                          # 11
-        r'|(?<=-)(%(space)s+)(?=-)'                            # 12
-        r'|(%(space)s+)'                                       # 13
-        r'|((?:%(newline)s%(space)s*)+)'                       # 14
+        r'|(?<=%(id_literal)s)(%(space)s+)(?=%(id_literal)s)'  # 12
+        r'|(?<=\+)(%(space)s+)(?=\+)'                          # 13
+        r'|(?<=-)(%(space)s+)(?=-)'                            # 14
+        r'|(%(space)s+)'                                       # 15
+        r'|((?:%(newline)s%(space)s*)+)'                       # 16
     ) % locals()).sub
 
-    # print space_sub_banged.__self__.pattern
+    # print(space_sub_banged.__self__.pattern)
 
     keep = _re.compile((
         r'%(space_chars)s+|%(space_comment_nobang)s+|%(newline)s+'
@@ -276,7 +293,7 @@ def _make_jsmin(python_only=False):
     ) % locals()).sub
     keeper = lambda m: m.groups()[0] or ''
 
-    # print keep.__self__.pattern
+    # print(keep.__self__.pattern)
 
     def space_subber_banged(match):
         """ Substitution callback """
@@ -288,26 +305,34 @@ def _make_jsmin(python_only=False):
         elif groups[1]:
             return groups[1]
         elif groups[3]:
-            return "%s%s%s%s" % (
+            return "%s%s" % (
                 keep(keeper, groups[2]),
                 groups[3],
-                keep(keeper, groups[4] or ''),
-                groups[4] and '\n' or '',
             )
-        elif groups[7]:
-            return "%s%s%s%s%s" % (
-                keep(keeper, groups[5]),
+        elif groups[5]:
+            return "%s%s%s%s" % (
+                keep(keeper, groups[4]),
+                groups[5],
+                keep(keeper, groups[6] or ''),
                 groups[6] and '\n' or '',
-                groups[7],
-                keep(keeper, groups[8] or ''),
-                groups[8] and '\n' or '',
             )
         elif groups[9]:
-            return keep(keeper, groups[9]) + '\n'
-        elif groups[10] or groups[11] or groups[12]:
-            return keep(keeper, groups[10] or groups[11] or groups[12]) or ' '
+            return "%s%s%s%s%s" % (
+                keep(keeper, groups[7]),
+                groups[8] and '\n' or '',
+                groups[9],
+                keep(keeper, groups[10] or ''),
+                groups[10] and '\n' or '',
+            )
+        elif groups[11]:
+            return keep(keeper, groups[11]) + '\n'
+        elif groups[12] or groups[13] or groups[14]:
+            return keep(keeper, groups[12] or groups[13] or groups[14]) or ' '
         else:
-            return keep(keeper, groups[13] or groups[14])
+            return keep(keeper, groups[15] or groups[16])
+
+    banged = _ft.partial(space_sub_banged, space_subber_banged)
+    simple = _ft.partial(space_sub_simple, space_subber_simple)
 
     def jsmin(script, keep_bang_comments=False):
         r"""
@@ -320,32 +345,51 @@ def _make_jsmin(python_only=False):
         .. _jsmin.c by Douglas Crockford:
            http://www.crockford.com/javascript/jsmin.c
 
-        :Parameters:
-          `script` : ``str``
+        Parameters:
+          script (str):
             Script to minify
 
-          `keep_bang_comments` : ``bool``
+          keep_bang_comments (bool):
             Keep comments starting with an exclamation mark? (``/*!...*/``)
 
-        :Return: Minified script
-        :Rtype: ``str``
+        Returns:
+          str: Minified script
         """
         # pylint: disable = redefined-outer-name
 
-        if keep_bang_comments:
-            return space_sub_banged(
-                space_subber_banged, '\n%s\n' % script
-            ).strip()
-        else:
-            return space_sub_simple(
-                space_subber_simple, '\n%s\n' % script
-            ).strip()
+        is_bytes, script = _as_str(script)
+        script = (banged if keep_bang_comments else simple)(
+            '\n%s\n' % script
+        ).strip()
+        if is_bytes:
+            script = script.encode('latin-1')
+            if is_bytes == 2:
+                script = bytearray(script)
+        return script
 
     return jsmin
 
 jsmin = _make_jsmin()
 
 
+def _as_str(script):
+    """ Make sure the script is a text string """
+    is_bytes = False
+    if str is bytes:
+        if not isinstance(script, basestring):  # noqa pylint: disable = undefined-variable
+            raise TypeError("Unexpected type")
+    elif isinstance(script, bytes):
+        is_bytes = True
+        script = script.decode('latin-1')
+    elif isinstance(script, bytearray):
+        is_bytes = 2
+        script = script.decode('latin-1')
+    elif not isinstance(script, str):
+        raise TypeError("Unexpected type")
+
+    return is_bytes, script
+
+
 def jsmin_for_posers(script, keep_bang_comments=False):
     r"""
     Minify javascript based on `jsmin.c by Douglas Crockford`_\.
@@ -361,49 +405,61 @@ def jsmin_for_posers(script, keep_bang_c
               utilizes the resulting regexes. It's here for fun and may
               vanish any time. Use the `jsmin` function instead.
 
-    :Parameters:
-      `script` : ``str``
+    Parameters:
+      script (str):
         Script to minify
 
-      `keep_bang_comments` : ``bool``
+      keep_bang_comments (bool):
         Keep comments starting with an exclamation mark? (``/*!...*/``)
 
-    :Return: Minified script
-    :Rtype: ``str``
+    Returns:
+      str: Minified script
     """
     if not keep_bang_comments:
         rex = (
-            r'([^\047"/\000-\040]+)|((?:(?:\047[^\047\\\r\n]*(?:\\(?:[^\r\n]'
-            r'|\r?\n|\r)[^\047\\\r\n]*)*\047)|(?:"[^"\\\r\n]*(?:\\(?:[^\r\n]'
-            r'|\r?\n|\r)[^"\\\r\n]*)*"))[^\047"/\000-\040]*)|(?<=[(,=:\[!&|?'
-            r'{};\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*'
-            r'][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\0'
-            r'14\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)*((?:/(?![\r'
-            r'\n/*])[^/\\\[\r\n]*(?:(?:\\[^\r\n]|(?:\[[^\\\]\r\n]*(?:\\[^\r'
-            r'\n][^\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*/))((?:[\000-\011\013\014'
+            r'([^\047"\140/\000-\040]+)|((?:(?:\047[^\047\\\r\n]*(?:\\(?:[^'
+            r'\r\n]|\r?\n|\r)[^\047\\\r\n]*)*\047)|(?:"[^"\\\r\n]*(?:\\(?:[^'
+            r'\r\n]|\r?\n|\r)[^"\\\r\n]*)*")|(?:\140[^\140\\]*(?:\\(?:[^\r\n'
+            r']|\r?\n|\r)[^\140\\]*)*\140))[^\047"\140/\000-\040]*)|(?<=[)])'
+            r'(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+'
+            r')*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\0'
+            r'40]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)*((?:/(?![\r\n/*])[^/'
+            r'\\\[\r\n]*(?:(?:\\[^\r\n]|(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]'
+            r'\r\n]*)*\]))[^/\\\[\r\n]*)*/[a-z]*))(?=(?:[\000-\011\013\014\0'
+            r'16-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r\n'
+            r']*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^'
+            r'/*][^*]*\*+)*/))*)*\.(?:[\000-\011\013\014\016-\040]|(?:/\*[^*'
+            r']*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\00'
+            r'0-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)'
+            r'*[a-z])|(?<=[(,=:\[!&|?{};\r\n+*-])(?:[\000-\011\013\014\016-'
+            r'\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)'
+            r'?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*]'
+            r'[^*]*\*+)*/))*)*((?:/(?![\r\n/*])[^/\\\[\r\n]*(?:(?:\\[^\r\n]|'
+            r'(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*'
+            r'/[a-z]*))((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/'
+            r'*][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013'
+            r'\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+(?=[^\000'
+            r'-\040&)+,.:;=?\]|}-]))?|(?<=[\000-#%-,./:-@\[-^\140{-~-]return'
+            r')(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*'
+            r'+)*/))*(?:((?:(?://[^\r\n]*)?[\r\n]))(?:[\000-\011\013\014\016'
+            r'-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)*((?:/(?![\r\n/*])'
+            r'[^/\\\[\r\n]*(?:(?:\\[^\r\n]|(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^'
+            r'\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*/[a-z]*))((?:[\000-\011\013\014'
             r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r'
             r'\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:'
-            r'[^/*][^*]*\*+)*/))*)+(?=[^\000-\040&)+,.:;=?\]|}-]))?|(?<=[\00'
-            r'0-#%-,./:-@\[-^`{-~-]return)(?:[\000-\011\013\014\016-\040]|(?'
-            r':/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:((?:(?://[^\r\n]*)?[\r\n]'
-            r'))(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*'
-            r'\*+)*/))*)*((?:/(?![\r\n/*])[^/\\\[\r\n]*(?:(?:\\[^\r\n]|(?:\['
-            r'[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*/))(('
-            r'?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)'
-            r'*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\04'
-            r'0]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+(?=[^\000-\040&)+,.:;'
-            r'=?\]|}-]))?|(?<=[^\000-!#%&(*,./:-@\[\\^`{|~])(?:[\000-\011\01'
-            r'3\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:((?:(?:'
-            r'//[^\r\n]*)?[\r\n]))(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]'
-            r'*\*+(?:[^/*][^*]*\*+)*/))*)+(?=[^\000-\040"#%-\047)*,./:-@\\-^'
-            r'`|-~])|(?<=[^\000-#%-,./:-@\[-^`{-~-])((?:[\000-\011\013\014\0'
-            r'16-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=[^\000-#%-,./'
-            r':-@\[-^`{-~-])|(?<=\+)((?:[\000-\011\013\014\016-\040]|(?:/\*['
-            r'^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=\+)|(?<=-)((?:[\000-\011\013'
-            r'\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=-)|(?:['
-            r'\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)'
-            r')+|(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]'
-            r'|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+'
+            r'[^/*][^*]*\*+)*/))*)+(?=[^\000-\040&)+,.:;=?\]|}-]))?|(?<=[^\0'
+            r'00-!#%&(*,./:-@\[\\^{|~])(?:[\000-\011\013\014\016-\040]|(?:/'
+            r'\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:((?:(?://[^\r\n]*)?[\r\n]))'
+            r'(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+'
+            r')*/))*)+(?=[^\000-\040"#%-\047)*,./:-@\\-^\140|-~])|(?<=[^\000'
+            r'-#%-,./:-@\[-^\140{-~-])((?:[\000-\011\013\014\016-\040]|(?:/'
+            r'\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=[^\000-#%-,./:-@\[-^\140{-'
+            r'~-])|(?<=\+)((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:'
+            r'[^/*][^*]*\*+)*/)))+(?=\+)|(?<=-)((?:[\000-\011\013\014\016-\0'
+            r'40]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=-)|(?:[\000-\011\0'
+            r'13\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+|(?:(?:(?'
+            r'://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]'
+            r'*\*+(?:[^/*][^*]*\*+)*/))*)+'
         )
 
         def subber(match):
@@ -412,59 +468,72 @@ def jsmin_for_posers(script, keep_bang_c
             return (
                 groups[0] or
                 groups[1] or
-                (groups[3] and (groups[2] + '\n')) or
                 groups[2] or
-                (groups[5] and "%s%s%s" % (
-                    groups[4] and '\n' or '',
-                    groups[5],
-                    groups[6] and '\n' or '',
+                (groups[4] and (groups[3] + '\n')) or
+                groups[3] or
+                (groups[6] and "%s%s%s" % (
+                    groups[5] and '\n' or '',
+                    groups[6],
+                    groups[7] and '\n' or '',
                 )) or
-                (groups[7] and '\n') or
-                (groups[8] and ' ') or
+                (groups[8] and '\n') or
                 (groups[9] and ' ') or
                 (groups[10] and ' ') or
+                (groups[11] and ' ') or
                 ''
             )
     else:
         rex = (
-            r'([^\047"/\000-\040]+)|((?:(?:\047[^\047\\\r\n]*(?:\\(?:[^\r\n]'
-            r'|\r?\n|\r)[^\047\\\r\n]*)*\047)|(?:"[^"\\\r\n]*(?:\\(?:[^\r\n]'
-            r'|\r?\n|\r)[^"\\\r\n]*)*"))[^\047"/\000-\040]*)|(?<=[(,=:\[!&|?'
-            r'{};\r\n])((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/'
-            r'*][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013'
-            r'\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)*)((?:/(?!'
-            r'[\r\n/*])[^/\\\[\r\n]*(?:(?:\\[^\r\n]|(?:\[[^\\\]\r\n]*(?:\\[^'
-            r'\r\n][^\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*/))((?:[\000-\011\013\01'
-            r'4\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^'
+            r'([^\047"\140/\000-\040]+)|((?:(?:\047[^\047\\\r\n]*(?:\\(?:[^'
+            r'\r\n]|\r?\n|\r)[^\047\\\r\n]*)*\047)|(?:"[^"\\\r\n]*(?:\\(?:[^'
+            r'\r\n]|\r?\n|\r)[^"\\\r\n]*)*")|(?:\140[^\140\\]*(?:\\(?:[^\r\n'
+            r']|\r?\n|\r)[^\140\\]*)*\140))[^\047"\140/\000-\040]*)|(?<=[)])'
+            r'((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*'
+            r'+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-'
+            r'\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)*)((?:/(?![\r\n/*])'
+            r'[^/\\\[\r\n]*(?:(?:\\[^\r\n]|(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^'
+            r'\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*/[a-z]*))(?=(?:[\000-\011\013\0'
+            r'14\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^'
             r'\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+('
-            r'?:[^/*][^*]*\*+)*/))*)+(?=[^\000-\040&)+,.:;=?\]|}-]))?|(?<=['
-            r'\000-#%-,./:-@\[-^`{-~-]return)((?:[\000-\011\013\014\016-\040'
-            r']|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:((?:(?://[^\r\n]*)?['
-            r'\r\n]))(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*]['
-            r'^*]*\*+)*/))*)*)((?:/(?![\r\n/*])[^/\\\[\r\n]*(?:(?:\\[^\r\n]|'
-            r'(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*'
-            r'/))((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]'
-            r'*\*+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\01'
-            r'6-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+(?=[^\000-\040&)'
-            r'+,.:;=?\]|}-]))?|(?<=[^\000-!#%&(*,./:-@\[\\^`{|~])((?:[\000-'
-            r'\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:'
-            r'(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/'
-            r'\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)(?=[^\000-\040"#%-\047)*,./'
-            r':-@\\-^`|-~])|(?<=[^\000-#%-,./:-@\[-^`{-~-])((?:[\000-\011\01'
-            r'3\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)(?=[^\000'
-            r'-#%-,./:-@\[-^`{-~-])|(?<=\+)((?:[\000-\011\013\014\016-\040]|'
-            r'(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)(?=\+)|(?<=-)((?:[\000-\0'
-            r'11\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)(?=-'
-            r')|((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*'
-            r'\*+)*/))+)|((?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014'
-            r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)'
+            r'?:[^/*][^*]*\*+)*/))*)*\.(?:[\000-\011\013\014\016-\040]|(?:/'
+            r'\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?'
+            r':[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*'
+            r'/))*)*[a-z])|(?<=[(,=:\[!&|?{};\r\n+*-])((?:[\000-\011\013\014'
+            r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r'
+            r'\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:'
+            r'[^/*][^*]*\*+)*/))*)*)((?:/(?![\r\n/*])[^/\\\[\r\n]*(?:(?:\\[^'
+            r'\r\n]|(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\]))[^/\\\[\r'
+            r'\n]*)*/[a-z]*))((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+'
+            r'(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\01'
+            r'1\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+(?=['
+            r'^\000-\040&)+,.:;=?\]|}-]))?|(?<=[\000-#%-,./:-@\[-^\140{-~-]r'
+            r'eturn)((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*]['
+            r'^*]*\*+)*/))*(?:((?:(?://[^\r\n]*)?[\r\n]))(?:[\000-\011\013\0'
+            r'14\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)*)((?:/(?!['
+            r'\r\n/*])[^/\\\[\r\n]*(?:(?:\\[^\r\n]|(?:\[[^\\\]\r\n]*(?:\\[^'
+            r'\r\n][^\\\]\r\n]*)*\]))[^/\\\[\r\n]*)*/[a-z]*))((?:[\000-\011'
+            r'\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:('
+            r'?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*'
+            r']*\*+(?:[^/*][^*]*\*+)*/))*)+(?=[^\000-\040&)+,.:;=?\]|}-]))?|'
+            r'(?<=[^\000-!#%&(*,./:-@\[\\^{|~])((?:[\000-\011\013\014\016-\0'
+            r'40]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*(?:(?:(?://[^\r\n]*)?['
+            r'\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^'
+            r'*]*\*+)*/))*)+)(?=[^\000-\040"#%-\047)*,./:-@\\-^\140|-~])|(?<'
+            r'=[^\000-#%-,./:-@\[-^\140{-~-])((?:[\000-\011\013\014\016-\040'
+            r']|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)(?=[^\000-#%-,./:-@\[-^'
+            r'\140{-~-])|(?<=\+)((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*'
+            r'\*+(?:[^/*][^*]*\*+)*/))+)(?=\+)|(?<=-)((?:[\000-\011\013\014'
+            r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)(?=-)|((?:[\00'
+            r'0-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)'
+            r'|((?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|'
+            r'(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)'
         )
 
-        keep = _re.compile((
+        keep = _re.compile(
             r'[\000-\011\013\014\016-\040]+|(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*'
             r'\*+)*/)+|(?:(?://[^\r\n]*)?[\r\n])+|((?:/\*![^*]*\*+(?:[^/*][^'
             r'*]*\*+)*/)+)'
-        ) % locals()).sub
+        ).sub
         keeper = lambda m: m.groups()[0] or ''
 
         def subber(match):
@@ -473,27 +542,37 @@ def jsmin_for_posers(script, keep_bang_c
             return (
                 groups[0] or
                 groups[1] or
-                (groups[3] and "%s%s%s%s" % (
+                groups[3] and "%s%s" % (
                     keep(keeper, groups[2]),
                     groups[3],
-                    keep(keeper, groups[4] or ''),
-                    groups[4] and '\n' or '',
-                )) or
-                (groups[7] and "%s%s%s%s%s" % (
-                    keep(keeper, groups[5]),
+                ) or
+                groups[5] and "%s%s%s%s" % (
+                    keep(keeper, groups[4]),
+                    groups[5],
+                    keep(keeper, groups[6] or ''),
                     groups[6] and '\n' or '',
-                    groups[7],
-                    keep(keeper, groups[8] or ''),
+                ) or
+                groups[9] and "%s%s%s%s%s" % (
+                    keep(keeper, groups[7]),
                     groups[8] and '\n' or '',
-                )) or
-                (groups[9] and keep(keeper, groups[9] + '\n')) or
-                (groups[10] and keep(keeper, groups[10]) or ' ') or
-                (groups[11] and keep(keeper, groups[11]) or ' ') or
-                (groups[12] and keep(keeper, groups[12]) or ' ') or
-                keep(keeper, groups[13] or groups[14])
+                    groups[9],
+                    keep(keeper, groups[10] or ''),
+                    groups[10] and '\n' or '',
+                ) or
+                groups[11] and (keep(keeper, groups[11]) + '\n') or
+                groups[12] and (keep(keeper, groups[12]) or ' ') or
+                groups[13] and (keep(keeper, groups[13]) or ' ') or
+                groups[14] and (keep(keeper, groups[14]) or ' ') or
+                keep(keeper, groups[15] or groups[16])
             )
 
-    return _re.sub(rex, subber, '\n%s\n' % script).strip()
+    is_bytes, script = _as_str(script)
+    script = _re.sub(rex, subber, '\n%s\n' % script).strip()
+    if is_bytes:
+        script = script.encode('latin-1')
+        if is_bytes == 2:
+            script = bytearray(script)
+    return script
 
 
 if __name__ == '__main__':
diff -up chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/setup.py.12 chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/setup.py
--- chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/setup.py.12	2022-06-28 12:50:10.171324444 +0000
+++ chromium-103.0.5060.53/third_party/catapult/common/py_vulcanize/third_party/rjsmin/setup.py	2021-11-05 17:03:12.000000000 +0000
@@ -1,41 +1,264 @@
 #!/usr/bin/env python
 # -*- coding: ascii -*-
-#
-# Copyright 2006 - 2013
-# Andr\xe9 Malo or his licensors, as applicable
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+u"""
+:Copyright:
 
+ Copyright 2011 - 2021
+ Andr\xe9 Malo or his licensors, as applicable
+
+:License:
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+===========================================
+ rJSmin - A Javascript Minifier For Python
+===========================================
+
+rJSmin - A Javascript Minifier For Python.
+"""
+from __future__ import print_function
+__author__ = u"Andr\xe9 Malo"
+__docformat__ = "restructuredtext en"
+
+import os as _os
+import posixpath as _posixpath
 import sys as _sys
-from _setup import run
 
+# pylint: disable = no-name-in-module, import-error, raise-missing-from
+import setuptools as _setuptools
+
+# pylint: disable = invalid-name
+
+
+def _doc(filename):
+    """ Read docs file """
+    # pylint: disable = unspecified-encoding
+    args = {} if str is bytes else dict(encoding='utf-8')
+    try:
+        with open(_os.path.join('docs', filename), **args) as fp:
+            return fp.read()
+    except IOError:
+        return None
+
+
+def _lines(multiline):
+    """ Split multiline string into single line % empty and comments """
+    return [line for line in (
+        line.strip() for line in multiline.splitlines(False)
+    ) if line and not line.startswith('#')]
+
+
+package = dict(
+    name='rjsmin',
+    top='.',
+    pathname='.',
+    provides=_doc('PROVIDES'),
+    desc=_doc('SUMMARY').strip(),
+    longdesc=_doc('DESCRIPTION'),
+    author=__author__,
+    email='nd@perlig.de',
+    license="Apache License, Version 2.0",
+    keywords=_lines(_doc('KEYWORDS')),
+    url='http://opensource.perlig.de/rjsmin/',
+    classifiers=_lines(_doc('CLASSIFIERS') or ''),
+
+    packages=False,
+    py_modules=['rjsmin'],
+    version_file='rjsmin.py',
+    install_requires=[],
+)
+
+
+class BuildFailed(Exception):
+    """ The build has failed """
+
+
+from distutils.command import build_ext as _build_ext  # pylint: disable = wrong-import-order
+from distutils import errors as _errors  # pylint: disable = wrong-import-order
+class build_ext(_build_ext.build_ext):  # pylint: disable = no-init
+    """ Improved extension building code """
+
+    def run(self):
+        """ Unify exception """
+        try:
+            _build_ext.build_ext.run(self)
+        except _errors.DistutilsPlatformError:
+            raise BuildFailed()
+
+
+    def build_extension(self, ext):
+        """
+        Build C extension - with extended functionality
 
-def setup(args=None, _manifest=0):
-    """ Main setup function """
-    from _setup.ext import Extension
+        The following features are added here:
 
-    if 'java' in _sys.platform.lower():
-        # no c extension for jython
-        ext = None
+        - The macros ``EXT_PACKAGE`` and ``EXT_MODULE`` will be filled (or
+          unset) depending on the extensions name, but only if they are not
+          already defined.
+
+        - "." is added to the include directories (for cext.h)
+
+        :Parameters:
+          `ext` : `Extension`
+            The extension to build
+
+        :Return: whatever ``distutils.command.build_ext.build_ext`` returns
+        :Rtype: any
+        """
+        # handle name macros
+        macros = dict(ext.define_macros or ())
+        tup = ext.name.split('.')
+        if len(tup) == 1:
+            pkg, mod = None, tup[0]
+        else:
+            pkg, mod = '.'.join(tup[:-1]), tup[-1]
+        if pkg is not None and 'EXT_PACKAGE' not in macros:
+            ext.define_macros.append(('EXT_PACKAGE', pkg))
+        if 'EXT_MODULE' not in macros:
+            ext.define_macros.append(('EXT_MODULE', mod))
+        if pkg is None:
+            macros = dict(ext.undef_macros or ())
+            if 'EXT_PACKAGE' not in macros:
+                ext.undef_macros.append('EXT_PACKAGE')
+
+        import pprint; pprint.pprint(ext.__dict__)
+        try:
+            return _build_ext.build_ext.build_extension(self, ext)
+        except (_errors.CCompilerError, _errors.DistutilsExecError,
+                _errors.DistutilsPlatformError, IOError, ValueError):
+            raise BuildFailed()
+
+
+class Extension(_setuptools.Extension):
+    """ improved functionality """
+
+    def __init__(self, *args, **kwargs):
+        """ Initialization """
+        version = kwargs.pop('version')
+        self.depends = []
+        if 'depends' in kwargs:
+            self.depends = kwargs['depends']
+        _setuptools.Extension.__init__(self, *args, **kwargs)
+        self.define_macros.append(('EXT_VERSION', version))
+
+        # add include path
+        included = '.'
+        if included not in self.include_dirs:
+            self.include_dirs.append(included)
+
+        # add cext.h to the dependencies
+        cext_h = _posixpath.normpath(_posixpath.join(included, 'cext.h'))
+        for item in self.depends:
+            if _posixpath.normpath(item) == cext_h:
+                break
+        else:
+            self.depends.append(cext_h)
+
+
+EXTENSIONS = lambda v: [Extension('_rjsmin', ["rjsmin.c"], version=v)]
+
+
+def do_setup(cext):
+    """ Main """
+    # pylint: disable = too-many-branches
+    # pylint: disable = unspecified-encoding
+
+    args = {} if str is bytes else dict(encoding='utf-8')
+    version_file = '%s/%s' % (package['pathname'],
+                              package.get('version_file', '__init__.py'))
+    with open(version_file, **args) as fp:
+        for line in fp:  # pylint: disable = redefined-outer-name
+            if line.startswith('__version__'):
+                version = line.split('=', 1)[1].strip()
+                if version.startswith(("'", '"')):
+                    version = version[1:-1].strip()
+                break
+        else:
+            raise RuntimeError("Version not found")
+
+    kwargs = {}
+
+    if not cext or 'java' in _sys.platform.lower():
+        extensions = []
     else:
-        ext=[Extension('_rjsmin', sources=['rjsmin.c'])]
+        extensions = EXTENSIONS(version)
+
+    if extensions:
+        if 'build_ext' in globals():
+            kwargs.setdefault('cmdclass', {})['build_ext'] = build_ext
+        kwargs['ext_modules'] = extensions
+
+        cflags = None
+        if _os.environ.get('CFLAGS') is None:
+            from distutils import ccompiler as _ccompiler
+
+            compiler = _ccompiler.get_default_compiler()
+            try:
+                with open("debug.%s.cflags" % compiler) as fp:
+                    cflags = ' '.join([
+                        line for line in (line.strip() for line in fp)
+                        if line and not line.startswith('#')
+                    ]).split() or None
+            except IOError:
+                pass
+
+        if cflags:
+            gcov = 'coverage' in ' '.join(cflags)
+            for ext in extensions:
+                # pylint: disable = attribute-defined-outside-init
+                ext.extra_compile_args = \
+                    getattr(ext, 'extra_compile_args', []) + cflags
+                if gcov:
+                    ext.libraries.append('gcov')
+
+
+    if package.get('packages', True):
+        kwargs['packages'] = [package['top']] + [
+            '%s.%s' % (package['top'], item)
+            for item in
+            _setuptools.find_packages(package['pathname'])
+        ]
+    if package.get('py_modules'):
+        kwargs['py_modules'] = package['py_modules']
 
-    return run(script_args=args, ext=ext, manifest_only=_manifest)
+    _setuptools.setup(
+        name=package['name'],
+        author=package['author'],
+        author_email=package['email'],
+        license=package['license'],
+        classifiers=package['classifiers'],
+        description=package['desc'],
+        long_description=package['longdesc'],
+        url=package['url'],
+        install_requires=package['install_requires'],
+        version=version,
+        zip_safe=False,
+        **kwargs
+    )
 
 
-def manifest():
-    """ Create List of packaged files """
-    return setup((), _manifest=1)
+def setup():
+    """ Run setup """
+    try:
+        do_setup(True)
+    except BuildFailed:
+        env = 'SETUP_CEXT_REQUIRED'
+        if _os.environ.get(env, '') not in ('', '0'):
+            raise
+        print("C extension build failed - building python only version now. "
+              "Set '%s' environment variable to '1' to make it fail."
+              % (env,), file=_sys.stderr)
+        do_setup(False)
 
 
 if __name__ == '__main__':