projen-pipelines 0.0.72 → 0.1.0

package/node_modules/handlebars/bin/handlebars

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+var argv = parseArgs({
+  'f': {
+    'type': 'string',
+    'description': 'Output File',
+    'alias': 'output'
+  },
+  'map': {
+    'type': 'string',
+    'description': 'Source Map File'
+  },
+  'a': {
+    'type': 'boolean',
+    'description': 'Exports amd style (require.js)',
+    'alias': 'amd'
+  },
+  'c': {
+    'type': 'string',
+    'description': 'Exports CommonJS style, path to Handlebars module',
+    'alias': 'commonjs',
+    'default': null
+  },
+  'h': {
+    'type': 'string',
+    'description': 'Path to handlebar.js (only valid for amd-style)',
+    'alias': 'handlebarPath',
+    'default': ''
+  },
+  'k': {
+    'type': 'string',
+    'description': 'Known helpers',
+    'alias': 'known'
+  },
+  'o': {
+    'type': 'boolean',
+    'description': 'Known helpers only',
+    'alias': 'knownOnly'
+  },
+  'm': {
+    'type': 'boolean',
+    'description': 'Minimize output',
+    'alias': 'min'
+  },
+  'n': {
+    'type': 'string',
+    'description': 'Template namespace',
+    'alias': 'namespace',
+    'default': 'Handlebars.templates'
+  },
+  's': {
+    'type': 'boolean',
+    'description': 'Output template function only.',
+    'alias': 'simple'
+  },
+  'N': {
+    'type': 'string',
+    'description': 'Name of passed string templates. Optional if running in a simple mode. Required when operating on multiple templates.',
+    'alias': 'name'
+  },
+  'i': {
+    'type': 'string',
+    'description': 'Generates a template from the passed CLI argument.\n"-" is treated as a special value and causes stdin to be read for the template value.',
+    'alias': 'string'
+  },
+  'r': {
+    'type': 'string',
+    'description': 'Template root. Base value that will be stripped from template names.',
+    'alias': 'root'
+  },
+  'p': {
+    'type': 'boolean',
+    'description': 'Compiling a partial template',
+    'alias': 'partial'
+  },
+  'd': {
+    'type': 'boolean',
+    'description': 'Include data when compiling',
+    'alias': 'data'
+  },
+  'e': {
+    'type': 'string',
+    'description': 'Template extension.',
+    'alias': 'extension',
+    'default': 'handlebars'
+  },
+  'b': {
+    'type': 'boolean',
+    'description': 'Removes the BOM (Byte Order Mark) from the beginning of the templates.',
+    'alias': 'bom'
+  },
+  'v': {
+    'type': 'boolean',
+    'description': 'Prints the current compiler version',
+    'alias': 'version'
+  },
+  'help': {
+    'type': 'boolean',
+    'description': 'Outputs this message'
+  }
+});
+
+argv.files = argv._;
+delete argv._;
+
+var Precompiler = require('../dist/cjs/precompiler');
+Precompiler.loadTemplates(argv, function(err, opts) {
+
+  if (err) {
+    throw err;
+  }
+
+  if (opts.help || (!opts.templates.length && !opts.version)) {
+    printUsage(argv._spec, 120);
+  } else {
+    Precompiler.cli(opts);
+  }
+});
+
+function pad(n) {
+  var str = '';
+  while (str.length < n) {
+    str += ' ';
+  }
+  return str;
+}
+
+function parseArgs(spec) {
+  var opts = { alias: {}, boolean: [], default: {}, string: [] };
+
+  Object.keys(spec).forEach(function (arg) {
+    var opt = spec[arg];
+    opts[opt.type].push(arg);
+    if ('alias' in opt) opts.alias[arg] = opt.alias;
+    if ('default' in opt) opts.default[arg] = opt.default;
+  });
+
+  var argv = require('minimist')(process.argv.slice(2), opts);
+  argv._spec = spec;
+  return argv;
+}
+
+function printUsage(spec, wrap) {
+  var wordwrap = require('wordwrap');
+
+  console.log('Precompile handlebar templates.');
+  console.log('Usage: handlebars [template|directory]...');
+
+  var opts = [];
+  var width = 0;
+  Object.keys(spec).forEach(function (arg) {
+    var opt = spec[arg];
+
+    var name = (arg.length === 1 ? '-' : '--') + arg;
+    if ('alias' in opt) name += ', --' + opt.alias;
+
+    var meta = '[' + opt.type + ']';
+    if ('default' in opt) meta += ' [default: ' + JSON.stringify(opt.default) + ']';
+
+    opts.push({ name: name, desc: opt.description, meta: meta });
+    if (name.length > width) width = name.length;
+  });
+
+  console.log('Options:');
+  opts.forEach(function (opt) {
+    var desc = wordwrap(width + 4, wrap + 1)(opt.desc);
+
+    console.log('  %s%s%s%s%s',
+      opt.name,
+      pad(width - opt.name.length + 2),
+      desc.slice(width + 4),
+      pad(wrap - opt.meta.length - desc.split(/\n/).pop().length),
+      opt.meta
+      );
+  });
+}

package/node_modules/handlebars/dist/amd/handlebars/base.js

@@ -0,0 +1,106 @@
+define(['exports', './utils', './exception', './helpers', './decorators', './logger', './internal/proto-access'], function (exports, _utils, _exception, _helpers, _decorators, _logger, _internalProtoAccess) {
+  'use strict';
+
+  exports.__esModule = true;
+  exports.HandlebarsEnvironment = HandlebarsEnvironment;
+  // istanbul ignore next
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  var _Exception = _interopRequireDefault(_exception);
+
+  var _logger2 = _interopRequireDefault(_logger);
+
+  var VERSION = '4.7.8';
+  exports.VERSION = VERSION;
+  var COMPILER_REVISION = 8;
+  exports.COMPILER_REVISION = COMPILER_REVISION;
+  var LAST_COMPATIBLE_COMPILER_REVISION = 7;
+
+  exports.LAST_COMPATIBLE_COMPILER_REVISION = LAST_COMPATIBLE_COMPILER_REVISION;
+  var REVISION_CHANGES = {
+    1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
+    2: '== 1.0.0-rc.3',
+    3: '== 1.0.0-rc.4',
+    4: '== 1.x.x',
+    5: '== 2.0.0-alpha.x',
+    6: '>= 2.0.0-beta.1',
+    7: '>= 4.0.0 <4.3.0',
+    8: '>= 4.3.0'
+  };
+
+  exports.REVISION_CHANGES = REVISION_CHANGES;
+  var objectType = '[object Object]';
+
+  function HandlebarsEnvironment(helpers, partials, decorators) {
+    this.helpers = helpers || {};
+    this.partials = partials || {};
+    this.decorators = decorators || {};
+
+    _helpers.registerDefaultHelpers(this);
+    _decorators.registerDefaultDecorators(this);
+  }
+
+  HandlebarsEnvironment.prototype = {
+    constructor: HandlebarsEnvironment,
+
+    logger: _logger2['default'],
+    log: _logger2['default'].log,
+
+    registerHelper: function registerHelper(name, fn) {
+      if (_utils.toString.call(name) === objectType) {
+        if (fn) {
+          throw new _Exception['default']('Arg not supported with multiple helpers');
+        }
+        _utils.extend(this.helpers, name);
+      } else {
+        this.helpers[name] = fn;
+      }
+    },
+    unregisterHelper: function unregisterHelper(name) {
+      delete this.helpers[name];
+    },
+
+    registerPartial: function registerPartial(name, partial) {
+      if (_utils.toString.call(name) === objectType) {
+        _utils.extend(this.partials, name);
+      } else {
+        if (typeof partial === 'undefined') {
+          throw new _Exception['default']('Attempting to register a partial called "' + name + '" as undefined');
+        }
+        this.partials[name] = partial;
+      }
+    },
+    unregisterPartial: function unregisterPartial(name) {
+      delete this.partials[name];
+    },
+
+    registerDecorator: function registerDecorator(name, fn) {
+      if (_utils.toString.call(name) === objectType) {
+        if (fn) {
+          throw new _Exception['default']('Arg not supported with multiple decorators');
+        }
+        _utils.extend(this.decorators, name);
+      } else {
+        this.decorators[name] = fn;
+      }
+    },
+    unregisterDecorator: function unregisterDecorator(name) {
+      delete this.decorators[name];
+    },
+    /**
+     * Reset the memory of illegal property accesses that have already been logged.
+     * @deprecated should only be used in handlebars test-cases
+     */
+    resetLoggedPropertyAccesses: function resetLoggedPropertyAccesses() {
+      _internalProtoAccess.resetLoggedProperties();
+    }
+  };
+
+  var log = _logger2['default'].log;
+
+  exports.log = log;
+  exports.createFrame = _utils.createFrame;
+  exports.logger = _logger2['default'];
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/node_modules/handlebars/dist/amd/handlebars/compiler/ast.js

@@ -0,0 +1,31 @@
+define(['exports', 'module'], function (exports, module) {
+  'use strict';
+
+  var AST = {
+    // Public API used to evaluate derived attributes regarding AST nodes
+    helpers: {
+      // a mustache is definitely a helper if:
+      // * it is an eligible helper, and
+      // * it has at least one parameter or hash segment
+      helperExpression: function helperExpression(node) {
+        return node.type === 'SubExpression' || (node.type === 'MustacheStatement' || node.type === 'BlockStatement') && !!(node.params && node.params.length || node.hash);
+      },
+
+      scopedId: function scopedId(path) {
+        return (/^\.|this\b/.test(path.original)
+        );
+      },
+
+      // an ID is simple if it only has one part, and that part is not
+      // `..` or `this`.
+      simpleId: function simpleId(path) {
+        return path.parts.length === 1 && !AST.helpers.scopedId(path) && !path.depth;
+      }
+    }
+  };
+
+  // Must be exported as an object rather than the root of the module as the jison lexer
+  // must modify the object to operate properly.
+  module.exports = AST;
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/node_modules/handlebars/dist/amd/handlebars/compiler/base.js

@@ -0,0 +1,45 @@
+define(['exports', './parser', './whitespace-control', './helpers', '../utils'], function (exports, _parser, _whitespaceControl, _helpers, _utils) {
+  'use strict';
+
+  exports.__esModule = true;
+  exports.parseWithoutProcessing = parseWithoutProcessing;
+  exports.parse = parse;
+  // istanbul ignore next
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  var _parser2 = _interopRequireDefault(_parser);
+
+  var _WhitespaceControl = _interopRequireDefault(_whitespaceControl);
+
+  exports.parser = _parser2['default'];
+
+  var yy = {};
+  _utils.extend(yy, _helpers);
+
+  function parseWithoutProcessing(input, options) {
+    // Just return if an already-compiled AST was passed in.
+    if (input.type === 'Program') {
+      return input;
+    }
+
+    _parser2['default'].yy = yy;
+
+    // Altering the shared object here, but this is ok as parser is a sync operation
+    yy.locInfo = function (locInfo) {
+      return new yy.SourceLocation(options && options.srcName, locInfo);
+    };
+
+    var ast = _parser2['default'].parse(input);
+
+    return ast;
+  }
+
+  function parse(input, options) {
+    var ast = parseWithoutProcessing(input, options);
+    var strip = new _WhitespaceControl['default'](options);
+
+    return strip.accept(ast);
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/node_modules/handlebars/dist/amd/handlebars/compiler/code-gen.js

@@ -0,0 +1,165 @@
+define(['exports', 'module', '../utils'], function (exports, module, _utils) {
+  /* global define, require */
+  'use strict';
+
+  var SourceNode = undefined;
+
+  try {
+    /* istanbul ignore next */
+    if (typeof define !== 'function' || !define.amd) {
+      // We don't support this in AMD environments. For these environments, we assume that
+      // they are running on the browser and thus have no need for the source-map library.
+      var SourceMap = require('source-map');
+      SourceNode = SourceMap.SourceNode;
+    }
+  } catch (err) {}
+  /* NOP */
+
+  /* istanbul ignore if: tested but not covered in istanbul due to dist build  */
+  if (!SourceNode) {
+    SourceNode = function (line, column, srcFile, chunks) {
+      this.src = '';
+      if (chunks) {
+        this.add(chunks);
+      }
+    };
+    /* istanbul ignore next */
+    SourceNode.prototype = {
+      add: function add(chunks) {
+        if (_utils.isArray(chunks)) {
+          chunks = chunks.join('');
+        }
+        this.src += chunks;
+      },
+      prepend: function prepend(chunks) {
+        if (_utils.isArray(chunks)) {
+          chunks = chunks.join('');
+        }
+        this.src = chunks + this.src;
+      },
+      toStringWithSourceMap: function toStringWithSourceMap() {
+        return { code: this.toString() };
+      },
+      toString: function toString() {
+        return this.src;
+      }
+    };
+  }
+
+  function castChunk(chunk, codeGen, loc) {
+    if (_utils.isArray(chunk)) {
+      var ret = [];
+
+      for (var i = 0, len = chunk.length; i < len; i++) {
+        ret.push(codeGen.wrap(chunk[i], loc));
+      }
+      return ret;
+    } else if (typeof chunk === 'boolean' || typeof chunk === 'number') {
+      // Handle primitives that the SourceNode will throw up on
+      return chunk + '';
+    }
+    return chunk;
+  }
+
+  function CodeGen(srcFile) {
+    this.srcFile = srcFile;
+    this.source = [];
+  }
+
+  CodeGen.prototype = {
+    isEmpty: function isEmpty() {
+      return !this.source.length;
+    },
+    prepend: function prepend(source, loc) {
+      this.source.unshift(this.wrap(source, loc));
+    },
+    push: function push(source, loc) {
+      this.source.push(this.wrap(source, loc));
+    },
+
+    merge: function merge() {
+      var source = this.empty();
+      this.each(function (line) {
+        source.add(['  ', line, '\n']);
+      });
+      return source;
+    },
+
+    each: function each(iter) {
+      for (var i = 0, len = this.source.length; i < len; i++) {
+        iter(this.source[i]);
+      }
+    },
+
+    empty: function empty() {
+      var loc = this.currentLocation || { start: {} };
+      return new SourceNode(loc.start.line, loc.start.column, this.srcFile);
+    },
+    wrap: function wrap(chunk) {
+      var loc = arguments.length <= 1 || arguments[1] === undefined ? this.currentLocation || { start: {} } : arguments[1];
+
+      if (chunk instanceof SourceNode) {
+        return chunk;
+      }
+
+      chunk = castChunk(chunk, this, loc);
+
+      return new SourceNode(loc.start.line, loc.start.column, this.srcFile, chunk);
+    },
+
+    functionCall: function functionCall(fn, type, params) {
+      params = this.generateList(params);
+      return this.wrap([fn, type ? '.' + type + '(' : '(', params, ')']);
+    },
+
+    quotedString: function quotedString(str) {
+      return '"' + (str + '').replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\u2028/g, '\\u2028') // Per Ecma-262 7.3 + 7.8.4
+      .replace(/\u2029/g, '\\u2029') + '"';
+    },
+
+    objectLiteral: function objectLiteral(obj) {
+      // istanbul ignore next
+
+      var _this = this;
+
+      var pairs = [];
+
+      Object.keys(obj).forEach(function (key) {
+        var value = castChunk(obj[key], _this);
+        if (value !== 'undefined') {
+          pairs.push([_this.quotedString(key), ':', value]);
+        }
+      });
+
+      var ret = this.generateList(pairs);
+      ret.prepend('{');
+      ret.add('}');
+      return ret;
+    },
+
+    generateList: function generateList(entries) {
+      var ret = this.empty();
+
+      for (var i = 0, len = entries.length; i < len; i++) {
+        if (i) {
+          ret.add(',');
+        }
+
+        ret.add(castChunk(entries[i], this));
+      }
+
+      return ret;
+    },
+
+    generateArray: function generateArray(entries) {
+      var ret = this.generateList(entries);
+      ret.prepend('[');
+      ret.add(']');
+
+      return ret;
+    }
+  };
+
+  module.exports = CodeGen;
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../lib/handlebars/compiler/code-gen.js"],"names":[],"mappings":"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","file":"code-gen.js","sourcesContent":["/* global define, require */\nimport { isArray } from '../utils';\n\nlet SourceNode;\n\ntry {\n  /* istanbul ignore next */\n  if (typeof define !== 'function' || !define.amd) {\n    // We don't support this in AMD environments. For these environments, we assume that\n    // they are running on the browser and thus have no need for the source-map library.\n    let SourceMap = require('source-map');\n    SourceNode = SourceMap.SourceNode;\n  }\n} catch (err) {\n  /* NOP */\n}\n\n/* istanbul ignore if: tested but not covered in istanbul due to dist build  */\nif (!SourceNode) {\n  SourceNode = function(line, column, srcFile, chunks) {\n    this.src = '';\n    if (chunks) {\n      this.add(chunks);\n    }\n  };\n  /* istanbul ignore next */\n  SourceNode.prototype = {\n    add: function(chunks) {\n      if (isArray(chunks)) {\n        chunks = chunks.join('');\n      }\n      this.src += chunks;\n    },\n    prepend: function(chunks) {\n      if (isArray(chunks)) {\n        chunks = chunks.join('');\n      }\n      this.src = chunks + this.src;\n    },\n    toStringWithSourceMap: function() {\n      return { code: this.toString() };\n    },\n    toString: function() {\n      return this.src;\n    }\n  };\n}\n\nfunction castChunk(chunk, codeGen, loc) {\n  if (isArray(chunk)) {\n    let ret = [];\n\n    for (let i = 0, len = chunk.length; i < len; i++) {\n      ret.push(codeGen.wrap(chunk[i], loc));\n    }\n    return ret;\n  } else if (typeof chunk === 'boolean' || typeof chunk === 'number') {\n    // Handle primitives that the SourceNode will throw up on\n    return chunk + '';\n  }\n  return chunk;\n}\n\nfunction CodeGen(srcFile) {\n  this.srcFile = srcFile;\n  this.source = [];\n}\n\nCodeGen.prototype = {\n  isEmpty() {\n    return !this.source.length;\n  },\n  prepend: function(source, loc) {\n    this.source.unshift(this.wrap(source, loc));\n  },\n  push: function(source, loc) {\n    this.source.push(this.wrap(source, loc));\n  },\n\n  merge: function() {\n    let source = this.empty();\n    this.each(function(line) {\n      source.add(['  ', line, '\\n']);\n    });\n    return source;\n  },\n\n  each: function(iter) {\n    for (let i = 0, len = this.source.length; i < len; i++) {\n      iter(this.source[i]);\n    }\n  },\n\n  empty: function() {\n    let loc = this.currentLocation || { start: {} };\n    return new SourceNode(loc.start.line, loc.start.column, this.srcFile);\n  },\n  wrap: function(chunk, loc = this.currentLocation || { start: {} }) {\n    if (chunk instanceof SourceNode) {\n      return chunk;\n    }\n\n    chunk = castChunk(chunk, this, loc);\n\n    return new SourceNode(\n      loc.start.line,\n      loc.start.column,\n      this.srcFile,\n      chunk\n    );\n  },\n\n  functionCall: function(fn, type, params) {\n    params = this.generateList(params);\n    return this.wrap([fn, type ? '.' + type + '(' : '(', params, ')']);\n  },\n\n  quotedString: function(str) {\n    return (\n      '\"' +\n      (str + '')\n        .replace(/\\\\/g, '\\\\\\\\')\n        .replace(/\"/g, '\\\\\"')\n        .replace(/\\n/g, '\\\\n')\n        .replace(/\\r/g, '\\\\r')\n        .replace(/\\u2028/g, '\\\\u2028') // Per Ecma-262 7.3 + 7.8.4\n        .replace(/\\u2029/g, '\\\\u2029') +\n      '\"'\n    );\n  },\n\n  objectLiteral: function(obj) {\n    let pairs = [];\n\n    Object.keys(obj).forEach(key => {\n      let value = castChunk(obj[key], this);\n      if (value !== 'undefined') {\n        pairs.push([this.quotedString(key), ':', value]);\n      }\n    });\n\n    let ret = this.generateList(pairs);\n    ret.prepend('{');\n    ret.add('}');\n    return ret;\n  },\n\n  generateList: function(entries) {\n    let ret = this.empty();\n\n    for (let i = 0, len = entries.length; i < len; i++) {\n      if (i) {\n        ret.add(',');\n      }\n\n      ret.add(castChunk(entries[i], this));\n    }\n\n    return ret;\n  },\n\n  generateArray: function(entries) {\n    let ret = this.generateList(entries);\n    ret.prepend('[');\n    ret.add(']');\n\n    return ret;\n  }\n};\n\nexport default CodeGen;\n"]}