pdf-creator-node 2.3.4 → 2.3.5

package/example/node_modules/uglify-js/lib/sourcemap.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -43,62 +43,153 @@
 
 "use strict";
 
-// a small wrapper around fitzgen's source-map library
-function SourceMap(options) {
-    options = defaults(options, {
-        file: null,
-        root: null,
-        orig: null,
-        orig_line_diff: 0,
-        dest_line_diff: 0,
-    }, true);
-    var generator = new MOZ_SourceMap.SourceMapGenerator({
-        file: options.file,
-        sourceRoot: options.root
-    });
-    var maps = options.orig && Object.create(null);
-    if (maps) for (var source in options.orig) {
-        var map = new MOZ_SourceMap.SourceMapConsumer(options.orig[source]);
-        if (Array.isArray(options.orig[source].sources)) {
-            map._sources.toArray().forEach(function(source) {
-                var sourceContent = map.sourceContentFor(source, true);
-                if (sourceContent) generator.setSourceContent(source, sourceContent);
-            });
+var vlq_char = characters("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+var vlq_bits = vlq_char.reduce(function(map, ch, bits) {
+    map[ch] = bits;
+    return map;
+}, Object.create(null));
+
+function vlq_decode(indices, str) {
+    var value = 0;
+    var shift = 0;
+    for (var i = 0, j = 0; i < str.length; i++) {
+        var bits = vlq_bits[str[i]];
+        value += (bits & 31) << shift;
+        if (bits & 32) {
+            shift += 5;
+        } else {
+            indices[j++] += value & 1 ? 0x80000000 | -(value >> 1) : value >> 1;
+            value = shift = 0;
         }
-        maps[source] = map;
     }
+    return j;
+}
+
+function vlq_encode(num) {
+    var result = "";
+    num = Math.abs(num) << 1 | num >>> 31;
+    do {
+        var bits = num & 31;
+        if (num >>>= 5) bits |= 32;
+        result += vlq_char[bits];
+    } while (num);
+    return result;
+}
+
+function create_array_map() {
+    var map = new Dictionary();
+    var array = [];
+    array.index = function(name) {
+        var index = map.get(name);
+        if (!(index >= 0)) {
+            index = array.length;
+            array.push(name);
+            map.set(name, index);
+        }
+        return index;
+    };
+    return array;
+}
+
+function SourceMap(options) {
+    var sources = create_array_map();
+    var sources_content = options.includeSources && new Dictionary();
+    var names = create_array_map();
+    var mappings = "";
+    if (options.orig) Object.keys(options.orig).forEach(function(name) {
+        var map = options.orig[name];
+        var indices = [ 0, 0, 1, 0, 0 ];
+        options.orig[name] = {
+            names: map.names,
+            mappings: map.mappings.split(/;/).map(function(line) {
+                indices[0] = 0;
+                return line.split(/,/).map(function(segment) {
+                    return indices.slice(0, vlq_decode(indices, segment));
+                });
+            }),
+            sources: map.sources,
+        };
+        if (!sources_content || !map.sourcesContent) return;
+        for (var i = 0; i < map.sources.length; i++) {
+            var content = map.sourcesContent[i];
+            if (content) sources_content.set(map.sources[i], content);
+        }
+    });
+    var prev_source;
+    var generated_line = 1;
+    var generated_column = 0;
+    var source_index = 0;
+    var original_line = 1;
+    var original_column = 0;
+    var name_index = 0;
     return {
-        add: function(source, gen_line, gen_col, orig_line, orig_col, name) {
-            var map = maps && maps[source];
+        add: options.orig ? function(source, gen_line, gen_col, orig_line, orig_col, name) {
+            var map = options.orig[source];
             if (map) {
-                var info = map.originalPositionFor({
-                    line: orig_line,
-                    column: orig_col
-                });
-                if (info.source === null) return;
-                source = info.source;
-                orig_line = info.line;
-                orig_col = info.column;
-                name = info.name || name;
-            }
-            generator.addMapping({
-                name: name,
-                source: source,
-                generated: {
-                    line: gen_line + options.dest_line_diff,
-                    column: gen_col
-                },
-                original: {
-                    line: orig_line + options.orig_line_diff,
-                    column: orig_col
+                var segments = map.mappings[orig_line - 1];
+                if (!segments) return;
+                var indices;
+                for (var i = 0; i < segments.length; i++) {
+                    var col = segments[i][0];
+                    if (orig_col >= col) indices = segments[i];
+                    if (orig_col <= col) break;
                 }
-            });
-        },
-        get: function() {
-            return generator;
-        },
+                if (!indices || indices.length < 4) {
+                    source = null;
+                } else {
+                    source = map.sources[indices[1]];
+                    orig_line = indices[2];
+                    orig_col = indices[3];
+                    if (indices.length > 4) name = map.names[indices[4]];
+                }
+            }
+            add(source, gen_line, gen_col, orig_line, orig_col, name);
+        } : add,
+        setSourceContent: sources_content ? function(source, content) {
+            if (!sources_content.has(source)) {
+                sources_content.set(source, content);
+            }
+        } : noop,
         toString: function() {
-            return JSON.stringify(generator.toJSON());
+            return JSON.stringify({
+                version: 3,
+                file: options.filename || undefined,
+                sourceRoot: options.root || undefined,
+                sources: sources,
+                sourcesContent: sources_content ? sources.map(function(source) {
+                    return sources_content.get(source) || null;
+                }) : undefined,
+                names: names,
+                mappings: mappings,
+            });
         }
     };
+
+    function add(source, gen_line, gen_col, orig_line, orig_col, name) {
+        if (prev_source == null && source == null) return;
+        prev_source = source;
+        if (generated_line < gen_line) {
+            generated_column = 0;
+            do {
+                mappings += ";";
+            } while (++generated_line < gen_line);
+        } else if (mappings) {
+            mappings += ",";
+        }
+        mappings += vlq_encode(gen_col - generated_column);
+        generated_column = gen_col;
+        if (source == null) return;
+        var src_idx = sources.index(source);
+        mappings += vlq_encode(src_idx - source_index);
+        source_index = src_idx;
+        mappings += vlq_encode(orig_line - original_line);
+        original_line = orig_line;
+        mappings += vlq_encode(orig_col - original_column);
+        original_column = orig_col;
+        if (options.names && name != null) {
+            var name_idx = names.index(name);
+            mappings += vlq_encode(name_idx - name_index);
+            name_index = name_idx;
+        }
+    }
 }

package/example/node_modules/uglify-js/lib/transform.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -82,7 +82,7 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.step) self.step = self.step.transform(tw);
         self.body = self.body.transform(tw);
     });
-    DEF(AST_ForIn, function(self, tw) {
+    DEF(AST_ForEnumeration, function(self, tw) {
         self.init = self.init.transform(tw);
         self.object = self.object.transform(tw);
         self.body = self.body.transform(tw);
@@ -116,7 +116,7 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
     });
     DEF(AST_Catch, function(self, tw) {
-        self.argname = self.argname.transform(tw);
+        if (self.argname) self.argname = self.argname.transform(tw);
         self.body = do_list(self.body, tw);
     });
     DEF(AST_Definitions, function(self, tw) {
@@ -126,11 +126,36 @@ TreeTransformer.prototype = new TreeWalker;
         self.name = self.name.transform(tw);
         if (self.value) self.value = self.value.transform(tw);
     });
+    DEF(AST_DefaultValue, function(self, tw) {
+        self.name = self.name.transform(tw);
+        self.value = self.value.transform(tw);
+    });
     DEF(AST_Lambda, function(self, tw) {
         if (self.name) self.name = self.name.transform(tw);
         self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
         self.body = do_list(self.body, tw);
     });
+    function transform_arrow(self, tw) {
+        self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
+        if (self.value) {
+            self.value = self.value.transform(tw);
+        } else {
+            self.body = do_list(self.body, tw);
+        }
+    }
+    DEF(AST_Arrow, transform_arrow);
+    DEF(AST_AsyncArrow, transform_arrow);
+    DEF(AST_Class, function(self, tw) {
+        if (self.name) self.name = self.name.transform(tw);
+        if (self.extends) self.extends = self.extends.transform(tw);
+        self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_ClassProperty, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
+        if (self.value) self.value = self.value.transform(tw);
+    });
     DEF(AST_Call, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.args = do_list(self.args, tw);
@@ -138,6 +163,12 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Sequence, function(self, tw) {
         self.expressions = do_list(self.expressions, tw);
     });
+    DEF(AST_Await, function(self, tw) {
+        self.expression = self.expression.transform(tw);
+    });
+    DEF(AST_Yield, function(self, tw) {
+        if (self.expression) self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Dot, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -145,6 +176,9 @@ TreeTransformer.prototype = new TreeWalker;
         self.expression = self.expression.transform(tw);
         self.property = self.property.transform(tw);
     });
+    DEF(AST_Spread, function(self, tw) {
+        self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Unary, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -160,12 +194,43 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Array, function(self, tw) {
         self.elements = do_list(self.elements, tw);
     });
+    DEF(AST_DestructuredArray, function(self, tw) {
+        self.elements = do_list(self.elements, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
+    });
+    DEF(AST_DestructuredKeyVal, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
+        self.value = self.value.transform(tw);
+    });
+    DEF(AST_DestructuredObject, function(self, tw) {
+        self.properties = do_list(self.properties, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
+    });
     DEF(AST_Object, function(self, tw) {
         self.properties = do_list(self.properties, tw);
     });
     DEF(AST_ObjectProperty, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
         self.value = self.value.transform(tw);
     });
+    DEF(AST_ExportDeclaration, function(self, tw) {
+        self.body = self.body.transform(tw);
+    });
+    DEF(AST_ExportDefault, function(self, tw) {
+        self.body = self.body.transform(tw);
+    });
+    DEF(AST_ExportReferences, function(self, tw) {
+        self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_Import, function(self, tw) {
+        if (self.all) self.all = self.all.transform(tw);
+        if (self.default) self.default = self.default.transform(tw);
+        if (self.properties) self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_Template, function(self, tw) {
+        if (self.tag) self.tag = self.tag.transform(tw);
+        self.expressions = do_list(self.expressions, tw);
+    });
 })(function(node, descend) {
     node.DEFMETHOD("transform", function(tw, in_list) {
         var x, y;

package/example/node_modules/uglify-js/lib/utils.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -55,14 +55,6 @@ function find_if(func, array) {
     for (var i = array.length; --i >= 0;) if (func(array[i])) return array[i];
 }
 
-function repeat_string(str, i) {
-    if (i <= 0) return "";
-    if (i == 1) return str;
-    var d = repeat_string(str, i >> 1);
-    d += d;
-    return i & 1 ? d + str : d;
-}
-
 function configure_error_stack(fn) {
     Object.defineProperty(fn.prototype, "stack", {
         get: function() {
@@ -87,24 +79,13 @@ DefaultsError.prototype.name = "DefaultsError";
 configure_error_stack(DefaultsError);
 
 function defaults(args, defs, croak) {
-    if (args === true) args = {};
-    var ret = args || {};
-    if (croak) for (var i in ret) if (HOP(ret, i) && !HOP(defs, i)) {
-        throw new DefaultsError("`" + i + "` is not a supported option", defs);
-    }
-    for (var i in defs) if (HOP(defs, i)) {
-        ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
+    if (croak) for (var i in args) {
+        if (HOP(args, i) && !HOP(defs, i)) throw new DefaultsError("`" + i + "` is not a supported option", defs);
     }
-    return ret;
-}
-
-function merge(obj, ext) {
-    var count = 0;
-    for (var i in ext) if (HOP(ext, i)) {
-        obj[i] = ext[i];
-        count++;
+    for (var i in args) {
+        if (HOP(args, i)) defs[i] = args[i];
     }
-    return count;
+    return defs;
 }
 
 function noop() {}
@@ -114,48 +95,29 @@ function return_this() { return this; }
 function return_null() { return null; }
 
 var List = (function() {
-    function List(a, f, backwards) {
-        var ret = [], top = [], i;
-        function doit() {
+    function List(a, f) {
+        var ret = [];
+        for (var i = 0; i < a.length; i++) {
             var val = f(a[i], i);
-            var is_last = val instanceof Last;
-            if (is_last) val = val.v;
-            if (val instanceof AtTop) {
-                val = val.v;
-                if (val instanceof Splice) {
-                    top.push.apply(top, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    top.push(val);
-                }
-            } else if (val !== skip) {
-                if (val instanceof Splice) {
-                    ret.push.apply(ret, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    ret.push(val);
-                }
-            }
-            return is_last;
-        }
-        if (Array.isArray(a)) {
-            if (backwards) {
-                for (i = a.length; --i >= 0;) if (doit()) break;
-                ret.reverse();
-                top.reverse();
+            if (val === skip) continue;
+            if (val instanceof Splice) {
+                ret.push.apply(ret, val.v);
             } else {
-                for (i = 0; i < a.length; ++i) if (doit()) break;
+                ret.push(val);
             }
-        } else {
-            for (i in a) if (HOP(a, i)) if (doit()) break;
         }
-        return top.concat(ret);
+        return ret;
     }
-    List.at_top = function(val) { return new AtTop(val); };
-    List.splice = function(val) { return new Splice(val); };
-    List.last = function(val) { return new Last(val); };
+    List.is_op = function(val) {
+        return val === skip || val instanceof Splice;
+    };
+    List.splice = function(val) {
+        return new Splice(val);
+    };
     var skip = List.skip = {};
-    function AtTop(val) { this.v = val; }
-    function Splice(val) { this.v = val; }
-    function Last(val) { this.v = val; }
+    function Splice(val) {
+        this.v = val;
+    }
     return List;
 })();
 
@@ -164,8 +126,9 @@ function push_uniq(array, el) {
 }
 
 function string_template(text, props) {
-    return text.replace(/\{(.+?)\}/g, function(str, p) {
-        return props && props[p];
+    return text.replace(/\{([^{}]+)\}/g, function(str, p) {
+        var value = props[p];
+        return value instanceof AST_Node ? value.print_to_string() : value;
     });
 }
 
@@ -191,57 +154,80 @@ function all(array, predicate) {
 }
 
 function Dictionary() {
-    this._values = Object.create(null);
-    this._size = 0;
+    this.values = Object.create(null);
 }
 Dictionary.prototype = {
     set: function(key, val) {
-        if (!this.has(key)) ++this._size;
-        this._values["$" + key] = val;
+        if (key == "__proto__") {
+            this.proto_value = val;
+        } else {
+            this.values[key] = val;
+        }
         return this;
     },
     add: function(key, val) {
-        if (this.has(key)) {
-            this.get(key).push(val);
+        var list = this.get(key);
+        if (list) {
+            list.push(val);
         } else {
             this.set(key, [ val ]);
         }
         return this;
     },
-    get: function(key) { return this._values["$" + key] },
+    get: function(key) {
+        return key == "__proto__" ? this.proto_value : this.values[key];
+    },
     del: function(key) {
-        if (this.has(key)) {
-            --this._size;
-            delete this._values["$" + key];
+        if (key == "__proto__") {
+            delete this.proto_value;
+        } else {
+            delete this.values[key];
         }
         return this;
     },
-    has: function(key) { return ("$" + key) in this._values },
+    has: function(key) {
+        return key == "__proto__" ? "proto_value" in this : key in this.values;
+    },
+    all: function(predicate) {
+        for (var i in this.values)
+            if (!predicate(this.values[i], i)) return false;
+        if ("proto_value" in this && !predicate(this.proto_value, "__proto__")) return false;
+        return true;
+    },
     each: function(f) {
-        for (var i in this._values)
-            f(this._values[i], i.substr(1));
+        for (var i in this.values)
+            f(this.values[i], i);
+        if ("proto_value" in this) f(this.proto_value, "__proto__");
     },
     size: function() {
-        return this._size;
+        return Object.keys(this.values).length + ("proto_value" in this);
     },
     map: function(f) {
         var ret = [];
-        for (var i in this._values)
-            ret.push(f(this._values[i], i.substr(1)));
+        for (var i in this.values)
+            ret.push(f(this.values[i], i));
+        if ("proto_value" in this) ret.push(f(this.proto_value, "__proto__"));
         return ret;
     },
     clone: function() {
         var ret = new Dictionary();
-        for (var i in this._values)
-            ret._values[i] = this._values[i];
-        ret._size = this._size;
+        this.each(function(value, i) {
+            ret.set(i, value);
+        });
         return ret;
     },
-    toObject: function() { return this._values }
+    toObject: function() {
+        var obj = {};
+        this.each(function(value, i) {
+            obj["$" + i] = value;
+        });
+        return obj;
+    },
 };
 Dictionary.fromObject = function(obj) {
     var dict = new Dictionary();
-    dict._size = merge(dict._values, obj);
+    for (var i in obj)
+        if (HOP(obj, i)) dict.set(i.slice(1), obj[i]);
     return dict;
 };
 
@@ -252,24 +238,48 @@ function HOP(obj, prop) {
 // return true if the node at the top of the stack (that means the
 // innermost node in the current output) is lexically the first in
 // a statement.
-function first_in_statement(stack) {
+function first_in_statement(stack, arrow, export_default) {
     var node = stack.parent(-1);
     for (var i = 0, p; p = stack.parent(i++); node = p) {
-        if (p.TYPE == "Call") {
-            if (p.expression === node) continue;
+        if (is_arrow(p)) {
+            return arrow && p.value === node;
         } else if (p instanceof AST_Binary) {
             if (p.left === node) continue;
+        } else if (p.TYPE == "Call") {
+            if (p.expression === node) continue;
         } else if (p instanceof AST_Conditional) {
             if (p.condition === node) continue;
+        } else if (p instanceof AST_ExportDefault) {
+            return export_default;
         } else if (p instanceof AST_PropAccess) {
             if (p.expression === node) continue;
         } else if (p instanceof AST_Sequence) {
             if (p.expressions[0] === node) continue;
-        } else if (p instanceof AST_Statement) {
-            return p.body === node;
+        } else if (p instanceof AST_SimpleStatement) {
+            return true;
+        } else if (p instanceof AST_Template) {
+            if (p.tag === node) continue;
         } else if (p instanceof AST_UnaryPostfix) {
             if (p.expression === node) continue;
         }
         return false;
     }
 }
+
+function DEF_BITPROPS(ctor, props) {
+    if (props.length > 31) throw new Error("Too many properties: " + props.length + "\n" + props.join(", "));
+    props.forEach(function(name, pos) {
+        var mask = 1 << pos;
+        Object.defineProperty(ctor.prototype, name, {
+            get: function() {
+                return !!(this._bits & mask);
+            },
+            set: function(val) {
+                if (val)
+                    this._bits |= mask;
+                else
+                    this._bits &= ~mask;
+            },
+        });
+    });
+}

package/example/node_modules/uglify-js/package.json

@@ -3,7 +3,7 @@
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.8.1",
+  "version": "3.16.3",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -11,7 +11,7 @@
     "Alex Lam <alexlamsl@gmail.com>",
     "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)"
   ],
-  "repository": "mishoo/UglifyJS2",
+  "repository": "mishoo/UglifyJS",
   "main": "tools/node.js",
   "bin": {
     "uglifyjs": "bin/uglifyjs"
@@ -22,12 +22,8 @@
     "tools",
     "LICENSE"
   ],
-  "dependencies": {
-    "commander": "~2.20.3",
-    "source-map": "~0.6.1"
-  },
   "devDependencies": {
-    "acorn": "~7.1.0",
+    "acorn": "~8.7.1",
     "semver": "~6.3.0"
   },
   "scripts": {