@zipify/wysiwyg 1.1.1-0 → 1.1.1

package/node_modules_lambda/escodegen/node_modules/levn/lib/coerce.js

@@ -0,0 +1,285 @@
+// Generated by LiveScript 1.2.0
+(function(){
+  var parsedTypeCheck, types, toString$ = {}.toString;
+  parsedTypeCheck = require('type-check').parsedTypeCheck;
+  types = {
+    '*': function(it){
+      switch (toString$.call(it).slice(8, -1)) {
+      case 'Array':
+        return coerceType(it, {
+          type: 'Array'
+        });
+      case 'Object':
+        return coerceType(it, {
+          type: 'Object'
+        });
+      default:
+        return {
+          type: 'Just',
+          value: coerceTypes(it, [
+            {
+              type: 'Undefined'
+            }, {
+              type: 'Null'
+            }, {
+              type: 'NaN'
+            }, {
+              type: 'Boolean'
+            }, {
+              type: 'Number'
+            }, {
+              type: 'Date'
+            }, {
+              type: 'RegExp'
+            }, {
+              type: 'Array'
+            }, {
+              type: 'Object'
+            }, {
+              type: 'String'
+            }
+          ], {
+            explicit: true
+          })
+        };
+      }
+    },
+    Undefined: function(it){
+      if (it === 'undefined' || it === void 8) {
+        return {
+          type: 'Just',
+          value: void 8
+        };
+      } else {
+        return {
+          type: 'Nothing'
+        };
+      }
+    },
+    Null: function(it){
+      if (it === 'null') {
+        return {
+          type: 'Just',
+          value: null
+        };
+      } else {
+        return {
+          type: 'Nothing'
+        };
+      }
+    },
+    NaN: function(it){
+      if (it === 'NaN') {
+        return {
+          type: 'Just',
+          value: NaN
+        };
+      } else {
+        return {
+          type: 'Nothing'
+        };
+      }
+    },
+    Boolean: function(it){
+      if (it === 'true') {
+        return {
+          type: 'Just',
+          value: true
+        };
+      } else if (it === 'false') {
+        return {
+          type: 'Just',
+          value: false
+        };
+      } else {
+        return {
+          type: 'Nothing'
+        };
+      }
+    },
+    Number: function(it){
+      return {
+        type: 'Just',
+        value: +it
+      };
+    },
+    Int: function(it){
+      return {
+        type: 'Just',
+        value: parseInt(it)
+      };
+    },
+    Float: function(it){
+      return {
+        type: 'Just',
+        value: parseFloat(it)
+      };
+    },
+    Date: function(value, options){
+      var that;
+      if (that = /^\#(.*)\#$/.exec(value)) {
+        return {
+          type: 'Just',
+          value: new Date(+that[1] || that[1])
+        };
+      } else if (options.explicit) {
+        return {
+          type: 'Nothing'
+        };
+      } else {
+        return {
+          type: 'Just',
+          value: new Date(+value || value)
+        };
+      }
+    },
+    RegExp: function(value, options){
+      var that;
+      if (that = /^\/(.*)\/([gimy]*)$/.exec(value)) {
+        return {
+          type: 'Just',
+          value: new RegExp(that[1], that[2])
+        };
+      } else if (options.explicit) {
+        return {
+          type: 'Nothing'
+        };
+      } else {
+        return {
+          type: 'Just',
+          value: new RegExp(value)
+        };
+      }
+    },
+    Array: function(it){
+      return coerceArray(it, {
+        of: [{
+          type: '*'
+        }]
+      });
+    },
+    Object: function(it){
+      return coerceFields(it, {
+        of: {}
+      });
+    },
+    String: function(it){
+      var that;
+      if (toString$.call(it).slice(8, -1) !== 'String') {
+        return {
+          type: 'Nothing'
+        };
+      }
+      if (that = it.match(/^'(.*)'$/)) {
+        return {
+          type: 'Just',
+          value: that[1]
+        };
+      } else if (that = it.match(/^"(.*)"$/)) {
+        return {
+          type: 'Just',
+          value: that[1]
+        };
+      } else {
+        return {
+          type: 'Just',
+          value: it
+        };
+      }
+    }
+  };
+  function coerceArray(node, type){
+    var typeOf, element;
+    if (toString$.call(node).slice(8, -1) !== 'Array') {
+      return {
+        type: 'Nothing'
+      };
+    }
+    typeOf = type.of;
+    return {
+      type: 'Just',
+      value: (function(){
+        var i$, ref$, len$, results$ = [];
+        for (i$ = 0, len$ = (ref$ = node).length; i$ < len$; ++i$) {
+          element = ref$[i$];
+          results$.push(coerceTypes(element, typeOf));
+        }
+        return results$;
+      }())
+    };
+  }
+  function coerceTuple(node, type){
+    var result, i$, ref$, len$, i, types, that;
+    if (toString$.call(node).slice(8, -1) !== 'Array') {
+      return {
+        type: 'Nothing'
+      };
+    }
+    result = [];
+    for (i$ = 0, len$ = (ref$ = type.of).length; i$ < len$; ++i$) {
+      i = i$;
+      types = ref$[i$];
+      if (that = coerceTypes(node[i], types)) {
+        result.push(that);
+      }
+    }
+    return {
+      type: 'Just',
+      value: result
+    };
+  }
+  function coerceFields(node, type){
+    var typeOf, key, value;
+    if (toString$.call(node).slice(8, -1) !== 'Object') {
+      return {
+        type: 'Nothing'
+      };
+    }
+    typeOf = type.of;
+    return {
+      type: 'Just',
+      value: (function(){
+        var ref$, results$ = {};
+        for (key in ref$ = node) {
+          value = ref$[key];
+          results$[key] = coerceTypes(value, typeOf[key] || [{
+            type: '*'
+          }]);
+        }
+        return results$;
+      }())
+    };
+  }
+  function coerceType(node, typeObj, options){
+    var type, structure, coerceFunc;
+    type = typeObj.type, structure = typeObj.structure;
+    if (type) {
+      coerceFunc = types[type];
+      return coerceFunc(node, options);
+    } else {
+      switch (structure) {
+      case 'array':
+        return coerceArray(node, typeObj);
+      case 'tuple':
+        return coerceTuple(node, typeObj);
+      case 'fields':
+        return coerceFields(node, typeObj);
+      }
+    }
+  }
+  function coerceTypes(node, types, options){
+    var i$, len$, type, ref$, valueType, value;
+    for (i$ = 0, len$ = types.length; i$ < len$; ++i$) {
+      type = types[i$];
+      ref$ = coerceType(node, type, options), valueType = ref$.type, value = ref$.value;
+      if (valueType === 'Nothing') {
+        continue;
+      }
+      if (parsedTypeCheck([type], value)) {
+        return value;
+      }
+    }
+    throw new Error("Value " + JSON.stringify(node) + " does not type check against " + JSON.stringify(types) + ".");
+  }
+  module.exports = coerceTypes;
+}).call(this);

package/node_modules_lambda/escodegen/node_modules/levn/lib/index.js

@@ -0,0 +1,22 @@
+// Generated by LiveScript 1.4.0
+(function(){
+  var parseString, cast, parseType, VERSION, parsedTypeParse, parse;
+  parseString = require('./parse-string');
+  cast = require('./cast');
+  parseType = require('type-check').parseType;
+  VERSION = '0.3.0';
+  parsedTypeParse = function(parsedType, string, options){
+    options == null && (options = {});
+    options.explicit == null && (options.explicit = false);
+    options.customTypes == null && (options.customTypes = {});
+    return cast(parseString(parsedType, string, options), parsedType, options);
+  };
+  parse = function(type, string, options){
+    return parsedTypeParse(parseType(type), string, options);
+  };
+  module.exports = {
+    VERSION: VERSION,
+    parse: parse,
+    parsedTypeParse: parsedTypeParse
+  };
+}).call(this);

package/node_modules_lambda/escodegen/node_modules/levn/lib/parse-string.js

@@ -0,0 +1,113 @@
+// Generated by LiveScript 1.4.0
+(function(){
+  var reject, special, tokenRegex;
+  reject = require('prelude-ls').reject;
+  function consumeOp(tokens, op){
+    if (tokens[0] === op) {
+      return tokens.shift();
+    } else {
+      throw new Error("Expected '" + op + "', but got '" + tokens[0] + "' instead in " + JSON.stringify(tokens) + ".");
+    }
+  }
+  function maybeConsumeOp(tokens, op){
+    if (tokens[0] === op) {
+      return tokens.shift();
+    }
+  }
+  function consumeList(tokens, arg$, hasDelimiters){
+    var open, close, result, untilTest;
+    open = arg$[0], close = arg$[1];
+    if (hasDelimiters) {
+      consumeOp(tokens, open);
+    }
+    result = [];
+    untilTest = "," + (hasDelimiters ? close : '');
+    while (tokens.length && (hasDelimiters && tokens[0] !== close)) {
+      result.push(consumeElement(tokens, untilTest));
+      maybeConsumeOp(tokens, ',');
+    }
+    if (hasDelimiters) {
+      consumeOp(tokens, close);
+    }
+    return result;
+  }
+  function consumeArray(tokens, hasDelimiters){
+    return consumeList(tokens, ['[', ']'], hasDelimiters);
+  }
+  function consumeTuple(tokens, hasDelimiters){
+    return consumeList(tokens, ['(', ')'], hasDelimiters);
+  }
+  function consumeFields(tokens, hasDelimiters){
+    var result, untilTest, key;
+    if (hasDelimiters) {
+      consumeOp(tokens, '{');
+    }
+    result = {};
+    untilTest = "," + (hasDelimiters ? '}' : '');
+    while (tokens.length && (!hasDelimiters || tokens[0] !== '}')) {
+      key = consumeValue(tokens, ':');
+      consumeOp(tokens, ':');
+      result[key] = consumeElement(tokens, untilTest);
+      maybeConsumeOp(tokens, ',');
+    }
+    if (hasDelimiters) {
+      consumeOp(tokens, '}');
+    }
+    return result;
+  }
+  function consumeValue(tokens, untilTest){
+    var out;
+    untilTest == null && (untilTest = '');
+    out = '';
+    while (tokens.length && -1 === untilTest.indexOf(tokens[0])) {
+      out += tokens.shift();
+    }
+    return out;
+  }
+  function consumeElement(tokens, untilTest){
+    switch (tokens[0]) {
+    case '[':
+      return consumeArray(tokens, true);
+    case '(':
+      return consumeTuple(tokens, true);
+    case '{':
+      return consumeFields(tokens, true);
+    default:
+      return consumeValue(tokens, untilTest);
+    }
+  }
+  function consumeTopLevel(tokens, types, options){
+    var ref$, type, structure, origTokens, result, finalResult, x$, y$;
+    ref$ = types[0], type = ref$.type, structure = ref$.structure;
+    origTokens = tokens.concat();
+    if (!options.explicit && types.length === 1 && ((!type && structure) || (type === 'Array' || type === 'Object'))) {
+      result = structure === 'array' || type === 'Array'
+        ? consumeArray(tokens, tokens[0] === '[')
+        : structure === 'tuple'
+          ? consumeTuple(tokens, tokens[0] === '(')
+          : consumeFields(tokens, tokens[0] === '{');
+      finalResult = tokens.length ? consumeElement(structure === 'array' || type === 'Array'
+        ? (x$ = origTokens, x$.unshift('['), x$.push(']'), x$)
+        : (y$ = origTokens, y$.unshift('('), y$.push(')'), y$)) : result;
+    } else {
+      finalResult = consumeElement(tokens);
+    }
+    return finalResult;
+  }
+  special = /\[\]\(\)}{:,/.source;
+  tokenRegex = RegExp('("(?:\\\\"|[^"])*")|(\'(?:\\\\\'|[^\'])*\')|(/(?:\\\\/|[^/])*/[a-zA-Z]*)|(#.*#)|([' + special + '])|([^\\s' + special + '](?:\\s*[^\\s' + special + ']+)*)|\\s*');
+  module.exports = function(types, string, options){
+    var tokens, node;
+    options == null && (options = {});
+    if (!options.explicit && types.length === 1 && types[0].type === 'String') {
+      return "'" + string.replace(/\\'/g, "\\\\'") + "'";
+    }
+    tokens = reject(not$, string.split(tokenRegex));
+    node = consumeTopLevel(tokens, types, options);
+    if (!node) {
+      throw new Error("Error parsing '" + string + "'.");
+    }
+    return node;
+  };
+  function not$(x){ return !x; }
+}).call(this);

package/node_modules_lambda/escodegen/node_modules/levn/lib/parse.js

@@ -0,0 +1,102 @@
+// Generated by LiveScript 1.2.0
+(function(){
+  var reject, special, tokenRegex;
+  reject = require('prelude-ls').reject;
+  function consumeOp(tokens, op){
+    if (tokens[0] === op) {
+      return tokens.shift();
+    } else {
+      throw new Error("Expected '" + op + "', but got '" + tokens[0] + "' instead in " + JSON.stringify(tokens) + ".");
+    }
+  }
+  function maybeConsumeOp(tokens, op){
+    if (tokens[0] === op) {
+      return tokens.shift();
+    }
+  }
+  function consumeList(tokens, delimiters, hasDelimiters){
+    var result;
+    if (hasDelimiters) {
+      consumeOp(tokens, delimiters[0]);
+    }
+    result = [];
+    while (tokens.length && tokens[0] !== delimiters[1]) {
+      result.push(consumeElement(tokens));
+      maybeConsumeOp(tokens, ',');
+    }
+    if (hasDelimiters) {
+      consumeOp(tokens, delimiters[1]);
+    }
+    return result;
+  }
+  function consumeArray(tokens, hasDelimiters){
+    return consumeList(tokens, ['[', ']'], hasDelimiters);
+  }
+  function consumeTuple(tokens, hasDelimiters){
+    return consumeList(tokens, ['(', ')'], hasDelimiters);
+  }
+  function consumeFields(tokens, hasDelimiters){
+    var result, key;
+    if (hasDelimiters) {
+      consumeOp(tokens, '{');
+    }
+    result = {};
+    while (tokens.length && (!hasDelimiters || tokens[0] !== '}')) {
+      key = tokens.shift();
+      consumeOp(tokens, ':');
+      result[key] = consumeElement(tokens);
+      maybeConsumeOp(tokens, ',');
+    }
+    if (hasDelimiters) {
+      consumeOp(tokens, '}');
+    }
+    return result;
+  }
+  function consumeElement(tokens){
+    switch (tokens[0]) {
+    case '[':
+      return consumeArray(tokens, true);
+    case '(':
+      return consumeTuple(tokens, true);
+    case '{':
+      return consumeFields(tokens, true);
+    default:
+      return tokens.shift();
+    }
+  }
+  function consumeTopLevel(tokens, types){
+    var ref$, type, structure, origTokens, result, finalResult, x$, y$;
+    ref$ = types[0], type = ref$.type, structure = ref$.structure;
+    origTokens = tokens.concat();
+    if (types.length === 1 && (structure || (type === 'Array' || type === 'Object'))) {
+      result = structure === 'array' || type === 'Array'
+        ? consumeArray(tokens, tokens[0] === '[')
+        : structure === 'tuple'
+          ? consumeTuple(tokens, tokens[0] === '(')
+          : consumeFields(tokens, tokens[0] === '{');
+      finalResult = tokens.length ? consumeElement(structure === 'array' || type === 'Array'
+        ? (x$ = origTokens, x$.unshift('['), x$.push(']'), x$)
+        : (y$ = origTokens, y$.unshift('('), y$.push(')'), y$)) : result;
+    } else {
+      finalResult = consumeElement(tokens);
+    }
+    if (tokens.length && origTokens.length) {
+      throw new Error("Unable to parse " + JSON.stringify(origTokens) + " of type " + JSON.stringify(types) + ".");
+    } else {
+      return finalResult;
+    }
+  }
+  special = /\[\]\(\)}{:,/.source;
+  tokenRegex = RegExp('("(?:[^"]|\\\\")*")|(\'(?:[^\']|\\\\\')*\')|(#.*#)|(/(?:\\\\/|[^/])*/[gimy]*)|([' + special + '])|([^\\s' + special + ']+)|\\s*');
+  module.exports = function(string, types){
+    var tokens, node;
+    tokens = reject(function(it){
+      return !it || /^\s+$/.test(it);
+    }, string.split(tokenRegex));
+    node = consumeTopLevel(tokens, types);
+    if (!node) {
+      throw new Error("Error parsing '" + string + "'.");
+    }
+    return node;
+  };
+}).call(this);

package/node_modules_lambda/escodegen/node_modules/levn/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "levn",
+  "version": "0.3.0",
+  "author": "George Zahariev <z@georgezahariev.com>",
+  "description": "Light ECMAScript (JavaScript) Value Notation - human written, concise, typed, flexible",
+  "homepage": "https://github.com/gkz/levn",
+  "keywords": [
+    "levn",
+    "light",
+    "ecmascript",
+    "value",
+    "notation",
+    "json",
+    "typed",
+    "human",
+    "concise",
+    "typed",
+    "flexible"
+  ],
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./lib/",
+  "bugs": "https://github.com/gkz/levn/issues",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 0.8.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/gkz/levn.git"
+  },
+  "scripts": {
+    "test": "make test"
+  },
+  "dependencies": {
+    "prelude-ls": "~1.1.2",
+    "type-check": "~0.3.2"
+  },
+  "devDependencies": {
+    "livescript": "~1.4.0",
+    "mocha": "~2.3.4",
+    "istanbul": "~0.4.1"
+  }
+}

package/node_modules_lambda/escodegen/node_modules/optionator/CHANGELOG.md

@@ -0,0 +1,56 @@
+# 0.8.3
+- changes dependency from `wordwrap` to `word-wrap` due to license issue
+- update dependencies
+
+# 0.8.2
+- fix bug #18 - detect missing value when flag is last item
+- update dependencies
+
+# 0.8.1
+- update `fast-levenshtein` dependency
+
+# 0.8.0
+- update `levn` dependency - supplying a float value to an option with type `Int` now throws an error, instead of silently converting to an `Int`
+
+# 0.7.1
+- fix bug with use of `defaults` and `concatRepeatedArrays` or `mergeRepeatedObjects`
+
+# 0.7.0
+- added `concatrepeatedarrays` option: `oneValuePerFlag`, only allows one array value per flag
+- added `typeAliases` option
+- added `parseArgv` which takes an array and parses with the first two items sliced off
+- changed enum help style
+- bug fixes (#12)
+- use of `concatRepeatedArrays` and `mergeRepeatedObjects` at the top level is deprecated, use it as either a per-option option, or set them in the `defaults` object to set them for all objects
+
+# 0.6.0
+- added `defaults` lib-option flag, allowing one to set default properties for all options
+- added `concatRepeatedArrays` and `mergeRepeatedObjects` as option level properties, allowing you to turn this feature on for specific options only
+
+# 0.5.0
+- `Boolean` flags with `default: 'true'`, and no short aliases, will by default show the `--no` version in help
+
+# 0.4.0
+- add `mergeRepeatedObjects` setting
+
+# 0.3.0
+- add `concatRepeatedArrays` setting
+- add `overrideRequired` option setting
+- use just Levenshtein string compare algo rather than Levenshtein Damerau to due dependency license issue
+
+# 0.2.2
+- bug fixes
+
+# 0.2.1
+- improved interpolation
+- added changelog
+
+# 0.2.0
+- add dependency checks to options - added `dependsOn` as an option property
+- add interpolation for `prepend` and `append` text with new `generateHelp` option, `interpolate`
+
+# 0.1.1
+- update dependencies
+
+# 0.1.0
+- initial release

package/node_modules_lambda/escodegen/node_modules/optionator/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) George Zahariev
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.