third_party/WebKit/Source/devtools/scripts/build/rjsmin.py - Issue 2553843002: [Devtools] Update RJSMin

Unified Diff: third_party/WebKit/Source/devtools/scripts/build/rjsmin.py

Issue 2553843002: [Devtools] Update RJSMin (Closed)

Patch Set: Created 4 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: third_party/WebKit/Source/devtools/scripts/build/rjsmin.py

diff --git a/third_party/WebKit/Source/devtools/scripts/build/rjsmin.py b/third_party/WebKit/Source/devtools/scripts/build/rjsmin.py

index 2d15e03fd35a51f8ced6bbd8c29afb80be2da7ad..54e20ec1c74a8b97e1baa88c12b437683d9bc4a2 100755

--- a/third_party/WebKit/Source/devtools/scripts/build/rjsmin.py

+++ b/third_party/WebKit/Source/devtools/scripts/build/rjsmin.py

@@ -1,19 +1,5 @@

#!/usr/bin/env python

-# 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.

+# -*- coding: ascii -*-

r"""

=====================

Javascript Minifier

@@ -21,7 +7,26 @@ r"""

rJSmin is a javascript minifier written in python.

-The minifier is based on the semantics of `jsmin.c by Douglas Crockford`_\.

+The minifier is based on the semantics of `jsmin.c by Douglas Crockford`_\\.

+:Copyright:

+ 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.

The module is a re-implementation aiming for speed, so it can be used at

runtime (rather than during a preprocessing step). Usually it produces the

@@ -30,22 +35,24 @@ same results as the original ``jsmin.c``. It differs in the following ways:

- there is no error detection: unterminated string, regex and comment

literals are treated as regular javascript code and minified as such.

- Control characters inside string and regex literals are left untouched; they

- are not converted to spaces (nor to \n)

+ are not converted to spaces (nor to \\n)

- Newline characters are not allowed inside string and regex literals, except

for line continuations in string literals (ECMA-5).

- "return /regex/" is recognized correctly.

+- Line terminators after regex literals are handled more sensibly

- "+ +" and "- -" sequences are not collapsed to '++' or '--'

- Newlines before ! operators are removed more sensibly

+- 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).

-Since most parts of the logic are handled by the regex engine it's way

-faster than the original python port of ``jsmin.c`` by Baruch Even. The speed

-factor varies between about 6 and 55 depending on input and python version

-(it gets faster the more compressed the input already is). Compared to the

+Since most parts of the logic are handled by the regex engine it's way faster

+than the original python port of ``jsmin.c`` by Baruch Even. The speed factor

+varies between about 6 and 55 depending on input and python version (it gets

+faster the more compressed the input already is). Compared to the

speed-refactored python port by Dave St.Germain the performance gain is less

-dramatic but still between 1.2 and 7. See the docs/BENCHMARKS file for

-details.

+dramatic but still between 3 and 50 (for huge inputs). See the docs/BENCHMARKS

+file for details.

rjsmin.c is a reimplementation of rjsmin.py in C and speeds it up even more.

@@ -54,11 +61,13 @@ Both python 2 and python 3 are supported.

.. _jsmin.c by Douglas Crockford:

http://www.crockford.com/javascript/jsmin.c

"""

-__author__ = "Andr\xe9 Malo"

-__author__ = getattr(__author__, 'decode', lambda x: __author__)('latin-1')

+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"

__license__ = "Apache License, Version 2.0"

-__version__ = '1.0.7'

+__version__ = '1.0.12'

__all__ = ['jsmin']

import re as _re

@@ -79,7 +88,9 @@ def _make_jsmin(python_only=False):

:Return: Minifier

:Rtype: ``callable``

"""

- # pylint: disable = R0912, R0914, W0612

+ # pylint: disable = unused-variable

+ # pylint: disable = too-many-locals

if not python_only:

try:

import _rjsmin

@@ -90,12 +101,15 @@ def _make_jsmin(python_only=False):

try:

xrange

except NameError:

- xrange = range # pylint: disable = W0622

+ xrange = range # pylint: disable = redefined-builtin

space_chars = r'[\000-\011\013\014\016-\040]'

line_comment = r'(?://[^\r\n]*)'

space_comment = r'(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)'

+ space_comment_nobang = r'(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*\*+)*/)'

+ bang_comment = r'(?:/\*![^*]*\*+(?:[^/*][^*]*\*+)*/)'

string1 = \

r'(?:\047[^\047\\\r\n]*(?:\\(?:[^\r\n]|\r?\n|\r)[^\047\\\r\n]*)*\047)'

string2 = r'(?:"[^"\\\r\n]*(?:\\(?:[^\r\n]|\r?\n|\r)[^"\\\r\n]*)*")'

@@ -105,7 +119,8 @@ def _make_jsmin(python_only=False):

charclass = r'(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\])'

nospecial = r'[^/\\\[\r\n]'

regex = r'(?:/(?![\r\n/*])%s*(?:(?:\\[^\r\n]|%s)%s*)*/)' % (

- nospecial, charclass, nospecial)

+ nospecial, charclass, nospecial

+ )

space = r'(?:%s|%s)' % (space_chars, space_comment)

newline = r'(?:%s?[\r\n])' % line_comment

@@ -135,24 +150,33 @@ def _make_jsmin(python_only=False):

return ''.join(['%s%s%s' % (

chr(first),

last > first + 1 and '-' or '',

- last != first and chr(last) or '') for first, last in result])

+ last != first and chr(last) or ''

+ ) for first, last in result]) # noqa

- return _re.sub(r'([\000-\040\047])', # for better portability

- lambda m: '\\%03o' % ord(m.group(1)), (sequentize(result)

+ return _re.sub(

+ r'([\000-\040\047])', # \047 for better portability

+ lambda m: '\\%03o' % ord(m.group(1)), (

+ sequentize(result)

.replace('\\', '\\\\')

.replace('[', '\\[')

- .replace(']', '\\]')))

+ .replace(']', '\\]')

+ )

def id_literal_(what):

""" Make id_literal like char class """

match = _re.compile(what).match

- result = ''.join([chr(c) for c in xrange(127) if not match(chr(c))])

+ result = ''.join([

+ chr(c) for c in xrange(127) if not match(chr(c))

+ ])

return '[^%s]' % fix_charclass(result)

def not_id_literal_(keep):

""" Make negated id_literal like char class """

match = _re.compile(id_literal_(keep)).match

- result = ''.join([chr(c) for c in xrange(127) if not match(chr(c))])

+ result = ''.join([

+ chr(c) for c in xrange(127) if not match(chr(c))

+ ])

return r'[%s]' % fix_charclass(result)

not_id_literal = not_id_literal_(r'[a-zA-Z0-9_$]')

@@ -162,48 +186,130 @@ def _make_jsmin(python_only=False):

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+-]')

+ post_regex_off = id_literal_(r'[^\000-\040}\])?:|,;.&=+-]')

dull = r'[^\047"`/\000-\040]'

- space_sub = _re.compile((

- r'(%(dull)s+)'

- r'|(%(strings)s%(dull)s*)'

+ space_sub_simple = _re.compile((

+ # noqa pylint: disable = bad-continuation

+ r'(%(dull)s+)' # 0

+ r'|(%(strings)s%(dull)s*)' # 1

r'|(?<=%(preregex1)s)'

r'%(space)s*(?:%(newline)s%(space)s*)*'

- r'(%(regex)s%(dull)s*)'

+ r'(%(regex)s)' # 2

+ r'(%(space)s*(?:%(newline)s%(space)s*)+' # 3

+ r'(?=%(post_regex_off)s))?'

r'|(?<=%(preregex2)s)'

- r'%(space)s*(?:%(newline)s%(space)s)*'

- r'(%(regex)s%(dull)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'|(?<=%(id_literal_close)s)'

- r'%(space)s*(?:(%(newline)s)%(space)s*)+'

+ r'%(space)s*(?:(%(newline)s)%(space)s*)+' # 7

r'(?=%(id_literal_open)s)'

- r'|(?<=%(id_literal)s)(%(space)s)+(?=%(id_literal)s)'

- r'|(?<=\+)(%(space)s)+(?=\+)'

- r'|(?<=-)(%(space)s)+(?=-)'

+ r'|(?<=%(id_literal)s)(%(space)s)+(?=%(id_literal)s)' # 8

+ r'|(?<=\+)(%(space)s)+(?=\+)' # 9

+ r'|(?<=-)(%(space)s)+(?=-)' # 10

r'|%(space)s+'

- r'|(?:%(newline)s%(space)s*)+') % locals()).sub

- #print space_sub.__self__.pattern

+ r'|(?:%(newline)s%(space)s*)+'

+ ) % locals()).sub

+ # print space_sub_simple.__self__.pattern

- def space_subber(match):

+ def space_subber_simple(match):

""" Substitution callback """

- # pylint: disable = C0321, R0911

+ # pylint: disable = too-many-return-statements

groups = match.groups()

if groups[0]:

return groups[0]

elif groups[1]:

return groups[1]

elif groups[2]:

+ if groups[3]:

+ return groups[2] + '\n'

return groups[2]

- elif groups[3]:

- return groups[3]

- elif groups[4]:

+ elif groups[5]:

+ return "%s%s%s" % (

+ groups[4] and '\n' or '',

+ groups[5],

+ groups[6] and '\n' or '',

+ )

+ elif groups[7]:

return '\n'

- elif groups[5] or groups[6] or groups[7]:

+ elif groups[8] or groups[9] or groups[10]:

return ' '

else:

return ''

- def jsmin(script): # pylint: disable = W0621

+ space_sub_banged = _re.compile((

+ # noqa pylint: disable = bad-continuation

+ r'(%(dull)s+)' # 0

+ r'|(%(strings)s%(dull)s*)' # 1

+ r'|(?<=%(preregex1)s)'

+ r'(%(space)s*(?:%(newline)s%(space)s*)*)' # 2

+ 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*)*)' # 5, 6

+ r'(%(regex)s)' # 7

+ r'(%(space)s*(?:%(newline)s%(space)s*)+' # 8

+ r'(?=%(post_regex_off)s))?'

+ r'|(?<=%(id_literal_close)s)'

+ r'(%(space)s*(?:%(newline)s%(space)s*)+)' # 9

+ 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

+ ) % locals()).sub

+ # print space_sub_banged.__self__.pattern

+ keep = _re.compile((

+ r'%(space_chars)s+|%(space_comment_nobang)s+|%(newline)s+'

+ r'|(%(bang_comment)s+)'

+ ) % locals()).sub

+ keeper = lambda m: m.groups()[0] or ''

+ # print keep.__self__.pattern

+ def space_subber_banged(match):

+ """ Substitution callback """

+ # pylint: disable = too-many-return-statements

+ groups = match.groups()

+ if groups[0]:

+ return groups[0]

+ elif groups[1]:

+ return groups[1]

+ elif groups[3]:

+ return "%s%s%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]),

+ 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 ' '

+ else:

+ return keep(keeper, groups[13] or groups[14])

+ def jsmin(script, keep_bang_comments=False):

r"""

Minify javascript based on `jsmin.c by Douglas Crockford`_\.

@@ -218,17 +324,29 @@ def _make_jsmin(python_only=False):

`script` : ``str``

Script to minify

+ `keep_bang_comments` : ``bool``

+ Keep comments starting with an exclamation mark? (``/*!...*/``)

:Return: Minified script

:Rtype: ``str``

"""

- return space_sub(space_subber, '\n%s\n' % script).strip()

+ # 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()

return jsmin

jsmin = _make_jsmin()

-def jsmin_for_posers(script):

+def jsmin_for_posers(script, keep_bang_comments=False):

r"""

Minify javascript based on `jsmin.c by Douglas Crockford`_\.

@@ -240,57 +358,158 @@ def jsmin_for_posers(script):

http://www.crockford.com/javascript/jsmin.c

:Warning: This function is the digest of a _make_jsmin() call. It just

- utilizes the resulting regex. It's just for fun here and may

+ utilizes the resulting regexes. It's here for fun and may

vanish any time. Use the `jsmin` function instead.

:Parameters:

`script` : ``str``

Script to minify

+ `keep_bang_comments` : ``bool``

+ Keep comments starting with an exclamation mark? (``/*!...*/``)

:Return: Minified script

:Rtype: ``str``

"""

- def subber(match):

- """ Substitution callback """

- groups = match.groups()

- return (

- groups[0] or

- groups[1] or

- groups[2] or

- groups[3] or

- (groups[4] and '\n') or

- (groups[5] and ' ') or

- (groups[6] and ' ') or

- (groups[7] and ' ') or

- '')

- return _re.sub(

- r'([^\047"/\000-\040]+)|((?:(?:\047[^\047\\\r\n]*(?:\\(?:[^\r\n]|\r?'

- r'\n|\r)[^\047\\\r\n]*)*\047)|(?:"[^"\\\r\n]*(?:\\(?:[^\r\n]|\r?\n|'

- r'\r)[^"\\\r\n]*)*"))[^\047"/\000-\040]*)|(?<=[(,=:\[!&|?{};\r\n])(?'

- r':[\000-\011\013\014\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]*)*/)[^\047"/\000-\040]*)|(?<=[\000-#%-,./:-@\[-^`{-~-]return'

- r')(?:[\000-\011\013\014\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]*)*/)[^\047"/\000-\040]*)|(?<=[^\000-!#%&(*,./:-@\[\\^`{|'

- r'~])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)'

- r'*/))*(?:((?:(?://[^\r\n]*)?[\r\n]))(?:[\000-\011\013\014\016-\040]'

- r'|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+(?=[^\000-\040"#%-\047)*,./'

- r':-@\\-^`|-~])|(?<=[^\000-#%-,./:-@\[-^`{-~-])((?:[\000-\011\013\01'

- r'4\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=[^\000-#%-,./:'

- r'-@\[-^`{-~-])|(?<=\+)((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*'

- r'\*+(?:[^/*][^*]*\*+)*/)))+(?=\+)|(?<=-)((?:[\000-\011\013\014\016-'

- r'\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=-)|(?:[\000-\011\013'

- r'\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+|(?:(?:(?://[^'

- r'\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^'

- r'/*][^*]*\*+)*/))*)+', subber, '\n%s\n' % script).strip()

+ 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'\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'|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+'

+ )

+ def subber(match):

+ """ Substitution callback """

+ groups = match.groups()

+ 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 '',

+ )) or

+ (groups[7] and '\n') or

+ (groups[8] and ' ') or

+ (groups[9] and ' ') or

+ (groups[10] 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'\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]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)'

+ )

+ keep = _re.compile((

+ r'[\000-\011\013\014\016-\040]+|(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*'

+ r'\*+)*/)+|(?:(?://[^\r\n]*)?[\r\n])+|((?:/\*![^*]*\*+(?:[^/*][^'

+ r'*]*\*+)*/)+)'

+ ) % locals()).sub

+ keeper = lambda m: m.groups()[0] or ''

+ def subber(match):

+ """ Substitution callback """

+ groups = match.groups()

+ return (

+ groups[0] or

+ groups[1] or

+ (groups[3] and "%s%s%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]),

+ groups[6] and '\n' or '',

+ groups[7],

+ keep(keeper, groups[8] or ''),

+ 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])

+ )

+ return _re.sub(rex, subber, '\n%s\n' % script).strip()

if __name__ == '__main__':

- import sys as _sys

- _sys.stdout.write(jsmin(_sys.stdin.read()))

+ def main():

+ """ Main """

+ import sys as _sys

+ argv = _sys.argv[1:]

+ keep_bang_comments = '-b' in argv or '-bp' in argv or '-pb' in argv

+ if '-p' in argv or '-bp' in argv or '-pb' in argv:

+ xjsmin = _make_jsmin(python_only=True)

+ else:

+ xjsmin = jsmin

+ _sys.stdout.write(xjsmin(

+ _sys.stdin.read(), keep_bang_comments=keep_bang_comments

+ ))

+ main()

« no previous file with comments | « no previous file | no next file » | no next file with comments »