@automattic/vip 4.1.5 → 4.1.8

package/node_modules/ejs/lib/cjs/parseargs.js

@@ -18,105 +18,157 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 var parseargs = {};
-var isOpt = function (arg) { return arg.indexOf('-') === 0; };
-var removeOptPrefix = function (opt) { return opt.replace(/^--/, '').replace(/^-/, ''); };
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = function (obj, key) { return hasOwnProperty.call(obj, key); };
+// A token is "option-like" if it begins with a dash. Such a token is never
+// consumed as an option-argument (a value that really starts with '-' must be
+// passed with '='), which turns the common "forgot the value" mistake into an
+// error instead of silently eating the next flag.
+var isOptionLike = function (s) {
+    return typeof s === 'string' && s.length > 0 && s.charAt(0) === '-';
+};
 /**
  * @constructor
- * Parses a list of command-line args into a key/value object of
- * options and an array of positional commands.
- * @param {Array} opts A list of options in the following format:
- * [{full: 'foo', abbr: 'f'}, {full: 'bar', abbr: 'b'}]]
+ * Parses command-line args into options and opaque operands.
+ *
+ * @param {Array} opts Option specs: `[{full, abbr, expectValue}]`. `expectValue`
+ *   truthy means the option takes a value; otherwise it is a boolean flag.
+ *
+ * `parse(argv)` returns `{opts, operands, errors}`:
+ *   - `opts`: null-prototype map of `full-name -> string | true` (last wins)
+ *   - `operands`: opaque positional args, in order (NOT split on '=')
+ *   - `errors`: `[{code, arg}]`, collected — never thrown. Codes:
+ *       'unknown-option', 'missing-value', 'unexpected-value'
+ *
+ * The parser is pure: no I/O, no exit, and it does not mutate `argv`.
  */
 parseargs.Parser = function (opts) {
-    // A key/value object of matching options parsed out of the args
-    this.opts = {};
-    this.taskNames = null;
-    this.envVars = null;
-    // Data structures used for parsing
-    this.reg = opts;
-    this.shortOpts = {};
-    this.longOpts = {};
+    // null-prototype lookup tables so inherited members ('constructor',
+    // 'toString', '__proto__', ...) can never resolve as a known option
+    this.short = Object.create(null);
+    this.long = Object.create(null);
     var self = this;
     [].forEach.call(opts, function (item) {
-        self.shortOpts[item.abbr] = item;
-        self.longOpts[item.full] = item;
+        self.short[item.abbr] = item;
+        self.long[item.full] = item;
     });
 };
-parseargs.Parser.prototype = new function () {
-    var _trueOrNextVal = function (argParts, args) {
-        if (argParts[1]) {
-            return argParts[1];
+parseargs.Parser.prototype.parse = function (argv) {
+    var opts = Object.create(null);
+    var operands = [];
+    var errors = [];
+    var self = this;
+    var longSpec = function (name) { return hasOwn(self.long, name) ? self.long[name] : null; };
+    var shortSpec = function (ch) { return hasOwn(self.short, ch) ? self.short[ch] : null; };
+    var i = 0;
+    var n = argv.length;
+    var endOfOpts = false;
+    while (i < n) {
+        var arg = argv[i];
+        // Everything after a bare '--' is an operand, even if it looks like an option.
+        if (endOfOpts) {
+            operands.push(arg);
+            i++;
+            continue;
         }
-        else {
-            return (!args[0] || isOpt(args[0])) ?
-                true : args.shift();
+        if (arg === '--') {
+            endOfOpts = true;
+            i++;
+            continue;
         }
-    };
-    /**
-     * Parses an array of arguments into options and positional commands
-     * @param {Array} args The command-line args to parse
-     */
-    this.parse = function (args) {
-        var cmds = [];
-        var cmd;
-        var envVars = {};
-        var opts = {};
-        var arg;
-        var argItem;
-        var argParts;
-        var cmdItems;
-        var taskNames = [];
-        var preempt;
-        while (args.length) {
-            arg = args.shift();
-            if (isOpt(arg)) {
-                arg = removeOptPrefix(arg);
-                argParts = arg.split('=');
-                argItem = this.longOpts[argParts[0]] || this.shortOpts[argParts[0]];
-                if (argItem) {
-                    // First-encountered preemptive opt takes precedence -- no further opts
-                    // or possibility of ambiguity, so just look for a value, or set to
-                    // true and then bail
-                    if (argItem.preempts) {
-                        opts[argItem.full] = _trueOrNextVal(argParts, args);
-                        preempt = true;
-                        break;
-                    }
-                    // If the opt requires a value, see if we can get a value from the
-                    // next arg, or infer true from no-arg -- if it's followed by another
-                    // opt, throw an error
-                    if (argItem.expectValue || argItem.allowValue) {
-                        opts[argItem.full] = _trueOrNextVal(argParts, args);
-                        if (argItem.expectValue && !opts[argItem.full]) {
-                            throw new Error(argItem.full + ' option expects a value.');
-                        }
+        // Long option: --name or --name=value  ('=' splits on the FIRST '=' only)
+        if (arg.slice(0, 2) === '--') {
+            var body = arg.slice(2);
+            var eq = body.indexOf('=');
+            var name_1 = eq === -1 ? body : body.slice(0, eq);
+            var attached = eq === -1 ? null : body.slice(eq + 1);
+            var spec = longSpec(name_1);
+            if (!spec) {
+                errors.push({ code: 'unknown-option', arg: '--' + name_1 });
+                i++;
+                continue;
+            }
+            if (spec.expectValue) {
+                if (attached !== null) {
+                    opts[spec.full] = attached;
+                    i++;
+                }
+                else {
+                    var next = argv[i + 1];
+                    if (next === undefined || isOptionLike(next)) {
+                        errors.push({ code: 'missing-value', arg: '--' + name_1 });
+                        i++;
                     }
                     else {
-                        opts[argItem.full] = true;
+                        opts[spec.full] = next;
+                        i += 2;
                     }
                 }
             }
             else {
-                cmds.unshift(arg);
+                if (attached !== null) {
+                    errors.push({ code: 'unexpected-value', arg: '--' + name_1 });
+                }
+                else {
+                    opts[spec.full] = true;
+                }
+                i++;
             }
+            continue;
         }
-        if (!preempt) {
-            // Parse out any env-vars and task-name
-            while ((cmd = cmds.pop())) {
-                cmdItems = cmd.split('=');
-                if (cmdItems.length > 1) {
-                    envVars[cmdItems[0]] = cmdItems[1];
+        // Short option(s): -x, -xyz (grouped), -xVALUE (attached), -x=VALUE
+        if (arg.charAt(0) === '-' && arg.length > 1) {
+            var j = 1;
+            var consumedNext = false;
+            while (j < arg.length) {
+                var ch = arg.charAt(j);
+                var spec = shortSpec(ch);
+                if (!spec) {
+                    errors.push({ code: 'unknown-option', arg: '-' + ch });
+                    break; // stop peeling this token on the first unknown char
                 }
-                else {
-                    taskNames.push(cmd);
+                if (spec.expectValue) {
+                    // The rest of the token is the value; a single leading '=' is a
+                    // separator (so -o=-weird.html -> '-weird.html', -m=| -> '|').
+                    var rest = arg.slice(j + 1);
+                    if (rest.length > 0) {
+                        if (rest.charAt(0) === '=') {
+                            rest = rest.slice(1);
+                        }
+                        opts[spec.full] = rest;
+                    }
+                    else {
+                        var next = argv[i + 1];
+                        if (next === undefined || isOptionLike(next)) {
+                            errors.push({ code: 'missing-value', arg: '-' + ch });
+                        }
+                        else {
+                            opts[spec.full] = next;
+                            consumedNext = true;
+                        }
+                    }
+                    break; // a value-taking option ends the group
                 }
+                opts[spec.full] = true; // boolean flag; keep peeling
+                j++;
             }
+            i += consumedNext ? 2 : 1;
+            continue;
+        }
+        // A bare '-' is not an operand and not a valid value.
+        if (arg === '-') {
+            errors.push({ code: 'unknown-option', arg: '-' });
+            i++;
+            continue;
         }
-        return {
-            opts: opts,
-            envVars: envVars,
-            taskNames: taskNames
-        };
+        // Anything else is an opaque operand.
+        operands.push(arg);
+        i++;
+    }
+    return {
+        opts: opts,
+        operands: operands,
+        errors: errors
     };
 };
 module.exports = parseargs;

package/node_modules/ejs/lib/cjs/utils.js

@@ -134,37 +134,6 @@ utils.shallowCopy = function (to, from) {
     }
     return to;
 };
-/**
- * Naive copy of a list of key names, from one object to another.
- * Only copies property if it is actually defined
- * Does not recurse into non-scalar properties
- *
- * @param  {Object} to   Destination object
- * @param  {Object} from Source object
- * @param  {Array} list List of properties to copy
- * @return {Object}      Destination object
- * @static
- * @private
- */
-utils.shallowCopyFromList = function (to, from, list) {
-    list = list || [];
-    from = from || {};
-    if ((to !== null) && (to !== undefined)) {
-        for (var i = 0; i < list.length; i++) {
-            var p = list[i];
-            if (typeof from[p] != 'undefined') {
-                if (!hasOwn(from, p)) {
-                    continue;
-                }
-                if (p === '__proto__' || p === 'constructor') {
-                    continue;
-                }
-                to[p] = from[p];
-            }
-        }
-    }
-    return to;
-};
 /**
  * Simple in-process cache implementation. Does not implement limits of any
  * sort.

package/node_modules/ejs/lib/esm/ejs.js

@@ -58,12 +58,6 @@ let _DEFAULT_CLOSE_DELIMITER = '>';
 let _DEFAULT_DELIMITER = '%';
 let _DEFAULT_LOCALS_NAME = 'locals';
 let _REGEX_STRING = '(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)';
-let _OPTS_PASSABLE_WITH_DATA = ['delimiter', 'scope', 'context', 'debug', 'compileDebug',
-  '_with', 'rmWhitespace', 'strict', 'filename', 'async'];
-// We don't allow 'cache' option to be passed in the data obj for
-// the normal `render` call, but this is where Express 2 & 3 put it
-// so we make an exception for `renderFile`
-let _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat('cache');
 let _BOM = /^\uFEFF/;
 let _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 
@@ -313,7 +307,8 @@ function includeFile(path, options) {
       if (includerResult.filename) {
         opts.filename = includerResult.filename;
       }
-      if (includerResult.template) {
+      // An empty string is a valid (empty) template, not "no template"
+      if (includerResult.template || includerResult.template === '') {
         return handleCache(opts, includerResult.template);
       }
     }
@@ -410,12 +405,6 @@ ejs.render = function (template, d, o) {
   let data = d || utils.createNullProtoObjWherePossible();
   let opts = o || utils.createNullProtoObjWherePossible();
 
-  // No options object -- if there are optiony names
-  // in the data, copy them to options
-  if (arguments.length == 2) {
-    utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
-  }
-
   return handleCache(opts, template)(data);
 };
 
@@ -438,7 +427,6 @@ ejs.renderFile = function () {
   let cb;
   let opts = {filename: filename};
   let data;
-  let viewOpts;
 
   // Do we have a callback?
   if (typeof arguments[arguments.length - 1] == 'function') {
@@ -446,35 +434,24 @@ ejs.renderFile = function () {
   }
   // Do we have data/opts?
   if (args.length) {
-    // Should always have data obj
+    // Should always have data obj; null/undefined means no data
     data = args.shift();
+    if (data == null) {
+      data = utils.createNullProtoObjWherePossible();
+    }
     // Normal passed opts (data obj + opts obj)
     if (args.length) {
       // Use shallowCopy so we don't pollute passed in opts obj with new vals
       utils.shallowCopy(opts, args.pop());
     }
-    // Special casing for Express (settings + opts-in-data)
-    else {
-      // Express 3 and 4
-      if (utils.hasOwn(data, 'settings') && data.settings) {
-        // Pull a few things from known locations
-        if (data.settings.views) {
-          opts.views = data.settings.views;
-        }
-        if (data.settings['view cache']) {
-          opts.cache = true;
-        }
-        // Undocumented after Express 2, but still usable, esp. for
-        // items that are unsafe to be passed along with data, like `root`
-        viewOpts = data.settings['view options'];
-        if (viewOpts) {
-          utils.shallowCopy(opts, viewOpts);
-        }
+    // Express passes app settings in with the data
+    else if (utils.hasOwn(data, 'settings') && data.settings) {
+      if (data.settings.views) {
+        opts.views = data.settings.views;
+      }
+      if (data.settings['view cache']) {
+        opts.cache = true;
       }
-      // Express 2 and lower, values set in app.locals, or people who just
-      // want to pass options in their data. NOTE: These values will override
-      // anything previously set in settings  or settings['view options']
-      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
     }
     opts.filename = filename;
   }
@@ -543,6 +520,36 @@ function Template(text, optsParam) {
   this.opts = options;
 
   this.regex = this.createRegex();
+  this.tags = buildTags(options);
+}
+
+// The tag strings for a set of delimiters, built once per template rather
+// than on every scanned token.
+function buildTags(opts) {
+  let o = opts.openDelimiter;
+  let d = opts.delimiter;
+  let c = opts.closeDelimiter;
+  return {
+    eval: o + d,
+    evalSlurp: o + d + '_',
+    escaped: o + d + '=',
+    raw: o + d + '-',
+    comment: o + d + '#',
+    literalOpen: o + d + d,
+    close: d + c,
+    closeTrim: '-' + d + c,
+    closeSlurp: '_' + d + c,
+    literalClose: d + d + c
+  };
+}
+
+// Count '\n' without allocating an array per token (as split() would).
+function countNewlines(str) {
+  let count = 0;
+  for (let i = str.indexOf('\n'); i !== -1; i = str.indexOf('\n', i + 1)) {
+    count++;
+  }
+  return count;
 }
 
 Template.modes = {
@@ -725,16 +732,13 @@ Template.prototype = {
     }
 
     let self = this;
-    let d = this.opts.delimiter;
-    let o = this.opts.openDelimiter;
-    let c = this.opts.closeDelimiter;
+    let tags = this.tags;
 
     // Slurp spaces and tabs before opening whitespace slurp tag and after closing whitespace slurp tag
-    // Build the tags using custom delimiters: openDelimiter + delimiter + '_' and '_' + delimiter + closeDelimiter
-    let openWhitespaceSlurpTag = utils.escapeRegExpChars(o + d + '_');
-    let closeWhitespaceSlurpTag = utils.escapeRegExpChars('_' + d + c);
-    let openWhitespaceSlurpReplacement = o + d + '_';
-    let closeWhitespaceSlurpReplacement = '_' + d + c;
+    let openWhitespaceSlurpTag = utils.escapeRegExpChars(tags.evalSlurp);
+    let closeWhitespaceSlurpTag = utils.escapeRegExpChars(tags.closeSlurp);
+    let openWhitespaceSlurpReplacement = tags.evalSlurp;
+    let closeWhitespaceSlurpReplacement = tags.closeSlurp;
     this.templateText =
       this.templateText.replace(new RegExp('[ \\t]*' + openWhitespaceSlurpTag, 'gm'), openWhitespaceSlurpReplacement)
         .replace(new RegExp(closeWhitespaceSlurpTag + '[ \\t]*', 'gm'), closeWhitespaceSlurpReplacement);
@@ -748,10 +752,10 @@ Template.prototype = {
         // FIXME: May end up with some false positives here
         // Better to store modes as k/v with openDelimiter + delimiter as key
         // Then this can simply check against the map
-        if ( line.indexOf(o + d) === 0        // If it is a tag
-          && line.indexOf(o + d + d) !== 0) { // and is not escaped
+        if ( line.indexOf(tags.eval) === 0        // If it is a tag
+          && line.indexOf(tags.literalOpen) !== 0) { // and is not escaped
           closing = matches[index + 2];
-          if (!(closing == d + c || closing == '-' + d + c || closing == '_' + d + c)) {
+          if (!(closing == tags.close || closing == tags.closeTrim || closing == tags.closeSlurp)) {
             throw new Error('Could not find matching close tag for "' + line + '".');
           }
         }
@@ -817,38 +821,35 @@ Template.prototype = {
 
   scanLine: function (line) {
     let self = this;
-    let d = this.opts.delimiter;
-    let o = this.opts.openDelimiter;
-    let c = this.opts.closeDelimiter;
-    let newLineCount = 0;
-
-    newLineCount = (line.split('\n').length - 1);
+    let tags = this.tags;
+    let newLineCount = countNewlines(line);
 
     switch (line) {
-    case o + d:
-    case o + d + '_':
+    case tags.eval:
+    case tags.evalSlurp:
       this.mode = Template.modes.EVAL;
       break;
-    case o + d + '=':
+    case tags.escaped:
       this.mode = Template.modes.ESCAPED;
       break;
-    case o + d + '-':
+    case tags.raw:
       this.mode = Template.modes.RAW;
       break;
-    case o + d + '#':
+    case tags.comment:
       this.mode = Template.modes.COMMENT;
       break;
-    case o + d + d:
+    case tags.literalOpen:
       this.mode = Template.modes.LITERAL;
-      this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")' + '\n';
+      // JSON.stringify quotes delimiter chars like " and \ safely
+      this.source += '    ; __append(' + JSON.stringify(tags.eval) + ')' + '\n';
       break;
-    case d + d + c:
+    case tags.literalClose:
       this.mode = Template.modes.LITERAL;
-      this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")' + '\n';
+      this.source += '    ; __append(' + JSON.stringify(tags.close) + ')' + '\n';
       break;
-    case d + c:
-    case '-' + d + c:
-    case '_' + d + c:
+    case tags.close:
+    case tags.closeTrim:
+    case tags.closeSlurp:
       if (this.mode == Template.modes.LITERAL) {
         this._addOutput(line);
       }