wice_grid 7.1.0 → 7.1.1

data/node_modules/recast/README.md

@@ -1,208 +0,0 @@
-# recast, _v_. [![Build Status](https://travis-ci.org/benjamn/recast.svg?branch=master)](https://travis-ci.org/benjamn/recast) [![Join the chat at https://gitter.im/benjamn/recast](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/benjamn/recast?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Greenkeeper badge](https://badges.greenkeeper.io/benjamn/recast.svg)](https://greenkeeper.io/)
-
-1. to give (a metal object) a different form by melting it down and reshaping it.
-1. to form, fashion, or arrange again.
-1. to remodel or reconstruct (a literary work, document, sentence, etc.).
-1. to supply (a theater or opera work) with a new cast.
-
-Installation
----
-
-From NPM:
-
-    npm install recast
-    
-From GitHub:
-
-    cd path/to/node_modules
-    git clone git://github.com/benjamn/recast.git
-    cd recast
-    npm install .
-
-Import style
----
-
-Recast is designed to be imported using **named** imports:
-```js
-import { parse, print } from "recast";
-console.log(print(parse(source)).code);
-
-import * as recast from "recast";
-console.log(recast.print(recast.parse(source)).code);
-```
-
-If you're using CommonJS:
-```js
-const { parse, print } = require("recast");
-console.log(print(parse(source)).code);
-
-const recast = require("recast");
-console.log(recast.print(recast.parse(source)).code);
-```
-
-Usage
----
-
-Recast exposes two essential interfaces, one for parsing JavaScript code (`require("recast").parse`) and the other for reprinting modified syntax trees (`require("recast").print`).
-
-Here's a simple but non-trivial example of how you might use `.parse` and `.print`:
-```js
-import * as recast from "recast";
-
-// Let's turn this function declaration into a variable declaration.
-const code = [
-  "function add(a, b) {",
-  "  return a +",
-  "    // Weird formatting, huh?",
-  "    b;",
-  "}"
-].join("\n");
-
-// Parse the code using an interface similar to require("esprima").parse.
-const ast = recast.parse(code);
-```
-Now do *whatever* you want to `ast`. Really, anything at all!
-
-See [ast-types](https://github.com/benjamn/ast-types) (especially the [def/core.ts](https://github.com/benjamn/ast-types/blob/master/def/core.ts)) module for a thorough overview of the `ast` API.
-```js
-// Grab a reference to the function declaration we just parsed.
-const add = ast.program.body[0];
-
-// Make sure it's a FunctionDeclaration (optional).
-const n = recast.types.namedTypes;
-n.FunctionDeclaration.assert(add);
-
-// If you choose to use recast.builders to construct new AST nodes, all builder
-// arguments will be dynamically type-checked against the Mozilla Parser API.
-const b = recast.types.builders;
-
-// This kind of manipulation should seem familiar if you've used Esprima or the
-// Mozilla Parser API before.
-ast.program.body[0] = b.variableDeclaration("var", [
-  b.variableDeclarator(add.id, b.functionExpression(
-    null, // Anonymize the function expression.
-    add.params,
-    add.body
-  ))
-]);
-
-// Just for fun, because addition is commutative:
-add.params.push(add.params.shift());
-```
-When you finish manipulating the AST, let `recast.print` work its magic:
-```js
-const output = recast.print(ast).code;
-```
-The `output` string now looks exactly like this, weird formatting and all:
-```js
-var add = function(b, a) {
-  return a +
-    // Weird formatting, huh?
-    b;
-}
-```
-The magic of Recast is that it reprints only those parts of the syntax tree that you modify. In other words, the following identity is guaranteed:
-```js
-recast.print(recast.parse(source)).code === source
-```
-Whenever Recast cannot reprint a modified node using the original source code, it falls back to using a generic pretty printer. So the worst that can happen is that your changes trigger some harmless reformatting of your code.
-
-If you really don't care about preserving the original formatting, you can access the pretty printer directly:
-```js
-var output = recast.prettyPrint(ast, { tabWidth: 2 }).code;
-```
-And here's the exact `output`:
-```js
-var add = function(b, a) {
-  return a + b;
-}
-```
-Note that the weird formatting was discarded, yet the behavior and abstract structure of the code remain the same.
-
-Using a different parser
----
-
-By default, Recast uses the [Esprima JavaScript parser](https://www.npmjs.com/package/esprima) when you call `recast.parse(code)`. While Esprima supports almost all modern ECMAScript syntax, you may want to use a different parser to enable TypeScript or Flow syntax, or just because you want to match other compilation tools you might be using.
-
-In order to get any benefits from Recast's conservative pretty-printing, **it is very important that you continue to call `recast.parse`** (rather than parsing the AST yourself using a different parser), and simply instruct `recast.parse` to use a different parser:
-
-```js
-const acornAst = recast.parse(source, {
-  parser: require("acorn")
-});
-```
-
-Why is this so important? When you call `recast.parse`, it makes a shadow copy of the AST before returning it to you, giving every copied AST node a reference back to the original through a special `.original` property. This information is what enables `recast.print` to detect where the AST has been modified, so that it can preserve formatting for parts of the AST that were not modified.
-
-Any `parser` object that supports a `parser.parse(source)` method will work here; however, if your parser requires additional options, you can always implement your own `parse` method that invokes your parser with custom options:
-
-```js
-const acornAst = recast.parse(source, {
-  parser: {
-    parse(source) {
-      return require("acorn").parse(source, {
-        // additional options
-      });
-    }
-  }
-});
-```
-
-To take some of the guesswork out of configuring common parsers, Recast provides [several preconfigured parsers](https://github.com/benjamn/recast/tree/master/parsers), so you can parse TypeScript (for example) without worrying about the configuration details:
-
-```js
-const tsAst = recast.parse(source, {
-  parser: require("recast/parsers/typescript")
-});
-```
-
-**Note:** Some of these parsers import npm packages that Recast does not directly depend upon, so please be aware you may have to run `npm install babylon@next` to use the `typescript`, `flow`, or `babylon` parsers, or `npm install acorn` to use the `acorn` parser. Only Esprima is installed by default when Recast is installed.
-
-Source maps
----
-
-One of the coolest consequences of tracking and reusing original source code during reprinting is that it's pretty easy to generate a high-resolution mapping between the original code and the generated code—completely automatically!
-
-With every `slice`, `join`, and re-`indent`-ation, the reprinting process maintains exact knowledge of which character sequences are original, and where in the original source they came from.
-
-All you have to think about is how to manipulate the syntax tree, and Recast will give you a [source map](https://github.com/mozilla/source-map) in exchange for specifying the names of your source file(s) and the desired name of the map:
-```js
-var result = recast.print(transform(recast.parse(source, {
-  sourceFileName: "source.js"
-})), {
-  sourceMapName: "map.json"
-});
-    
-console.log(result.code); // Resulting string of code.
-console.log(result.map); // JSON source map.
-
-var SourceMapConsumer = require("source-map").SourceMapConsumer;
-var smc = new SourceMapConsumer(result.map);
-console.log(smc.originalPositionFor({
-  line: 3,
-  column: 15
-})); // { source: 'source.js',
-     //   line: 2,
-     //   column: 10,
-     //   name: null }
-```
-
-Note that you are free to mix and match syntax trees parsed from different source files, and the resulting source map will automatically keep track of the separate file origins for you.
-
-Note also that the source maps generated by Recast are character-by-character maps, so meaningful identifier names are not recorded at this time. This approach leads to higher-resolution debugging in modern browsers, at the expense of somewhat larger map sizes. Striking the perfect balance here is an area for future exploration, but such improvements will not require any breaking changes to the interface demonstrated above.
-
-Options
----
-All Recast API functions take second parameter with configuration options, documented in
-[options.ts](https://github.com/benjamn/recast/blob/master/lib/options.ts)
-
-Motivation
----
-
-The more code you have, the harder it becomes to make big, sweeping changes quickly and confidently. Even if you trust yourself not to make too many mistakes, and no matter how proficient you are with your text editor, changing tens of thousands of lines of code takes precious, non-refundable time.
-
-Is there a better way? Not always! When a task requires you to alter the semantics of many different pieces of code in subtly different ways, your brain inevitably becomes the bottleneck, and there is little hope of completely automating the process. Your best bet is to plan carefully, buckle down, and get it right the first time. Love it or loathe it, that's the way programming goes sometimes.
-
-What I hope to eliminate are the brain-wasting tasks, the tasks that are bottlenecked by keystrokes, the tasks that can be expressed as operations on the _syntactic structure_ of your code. Specifically, my goal is to make it possible for you to run your code through a parser, manipulate the abstract syntax tree directly, subject only to the constraints of your imagination, and then automatically translate those modifications back into source code, without upsetting the formatting of unmodified code.
-
-And here's the best part: when you're done running a Recast script, if you're not completely satisfied with the results, blow them away with `git reset --hard`, tweak the script, and just run it again. Change your mind as many times as you like. Instead of typing yourself into a nasty case of [RSI](http://en.wikipedia.org/wiki/Repetitive_strain_injury), gaze upon your new wells of free time and ask yourself: what next?

data/node_modules/recast/example/add-braces

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-
-var recast = require("recast");
-var types = recast.types;
-var n = types.namedTypes;
-var b = types.builders;
-
-require("recast").run(function(ast, callback) {
-    recast.visit(ast, {
-        visitIfStatement: function(path) {
-            var stmt = path.node;
-            stmt.consequent = fix(stmt.consequent);
-
-            var alt = stmt.alternate;
-            if (!n.IfStatement.check(alt)) {
-                stmt.alternate = fix(alt);
-            }
-
-            this.traverse(path);
-        },
-
-        visitWhileStatement: visitLoop,
-        visitForStatement: visitLoop,
-        visitForInStatement: visitLoop
-    });
-
-    callback(ast);
-});
-
-function visitLoop(path) {
-    var loop = path.node;
-    loop.body = fix(loop.body);
-    this.traverse(path);
-}
-
-function fix(clause) {
-    if (clause) {
-        if (!n.BlockStatement.check(clause)) {
-            clause = b.blockStatement([clause]);
-        }
-    }
-
-    return clause;
-}

data/node_modules/recast/example/generic-identity

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-
-// This script should reprint the contents of the given file without
-// reusing the original source, but with identical AST structure.
-
-var recast = require("recast");
-
-recast.run(function(ast, callback) {
-    recast.visit(ast, {
-        visitNode: function(path) {
-            this.traverse(path);
-            path.node.original = null;
-        }
-    });
-
-    callback(ast);
-});

data/node_modules/recast/example/identity

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-// This script should echo the contents of the given file without
-// modification.
-
-require("recast").run(function(ast, callback) {
-    callback(ast);
-});

data/node_modules/recast/example/to-while

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-
-// This script converts for and do-while loops into equivalent while loops.
-// Note that for-in statements are left unmodified, as they do not have a
-// simple analogy to while loops. Also note that labeled continue statements
-// are not correctly handled at this point, and will trigger an assertion
-// failure if encountered.
-
-var assert = require("assert");
-var recast = require("recast");
-var types = recast.types;
-var n = types.namedTypes;
-var b = types.builders;
-
-recast.run(function(ast, callback) {
-    recast.visit(ast, {
-        visitForStatement: function(path) {
-            var fst = path.node;
-
-            path.replace(
-                fst.init,
-                b.whileStatement(
-                    fst.test,
-                    insertBeforeLoopback(fst, fst.update)
-                )
-            );
-
-            this.traverse(path);
-        },
-
-        visitDoWhileStatement: function(path) {
-            var dwst = path.node;
-            return b.whileStatement(
-                b.literal(true),
-                insertBeforeLoopback(
-                    dwst,
-                    b.ifStatement(
-                        dwst.test,
-                        b.breakStatement()
-                    )
-                )
-            );
-        }
-    });
-
-    callback(ast);
-});
-
-function insertBeforeLoopback(loop, toInsert) {
-    var body = loop.body;
-
-    if (!n.Statement.check(toInsert)) {
-        toInsert = b.expressionStatement(toInsert);
-    }
-
-    if (n.BlockStatement.check(body)) {
-        body.body.push(toInsert);
-    } else {
-        body = b.blockStatement([body, toInsert]);
-        loop.body = body;
-    }
-
-    recast.visit(body, {
-        visitContinueStatement: function(path) {
-            var cst = path.node;
-
-            assert.equal(
-                cst.label, null,
-                "Labeled continue statements are not yet supported."
-            );
-
-            path.replace(toInsert, path.node);
-            return false;
-        },
-
-        // Do not descend into nested loops.
-        visitWhileStatement: function() {},
-        visitForStatement: function() {},
-        visitForInStatement: function() {},
-        visitDoWhileStatement: function() {}
-    });
-
-    return body;
-}

data/node_modules/recast/lib/comments.d.ts

@@ -1,2 +0,0 @@
-export declare function attach(comments: any[], ast: any, lines: any): void;
-export declare function printComments(path: any, print: any): any;

data/node_modules/recast/lib/comments.js

@@ -1,308 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __importDefault(require("assert"));
-var types = __importStar(require("ast-types"));
-var n = types.namedTypes;
-var isArray = types.builtInTypes.array;
-var isObject = types.builtInTypes.object;
-var lines_1 = require("./lines");
-var util_1 = require("./util");
-var private_1 = require("private");
-var childNodesCacheKey = private_1.makeUniqueKey();
-// TODO Move a non-caching implementation of this function into ast-types,
-// and implement a caching wrapper function here.
-function getSortedChildNodes(node, lines, resultArray) {
-    if (!node) {
-        return;
-    }
-    // The .loc checks below are sensitive to some of the problems that
-    // are fixed by this utility function. Specifically, if it decides to
-    // set node.loc to null, indicating that the node's .loc information
-    // is unreliable, then we don't want to add node to the resultArray.
-    util_1.fixFaultyLocations(node, lines);
-    if (resultArray) {
-        if (n.Node.check(node) &&
-            n.SourceLocation.check(node.loc)) {
-            // This reverse insertion sort almost always takes constant
-            // time because we almost always (maybe always?) append the
-            // nodes in order anyway.
-            for (var i = resultArray.length - 1; i >= 0; --i) {
-                if (util_1.comparePos(resultArray[i].loc.end, node.loc.start) <= 0) {
-                    break;
-                }
-            }
-            resultArray.splice(i + 1, 0, node);
-            return;
-        }
-    }
-    else if (node[childNodesCacheKey]) {
-        return node[childNodesCacheKey];
-    }
-    var names;
-    if (isArray.check(node)) {
-        names = Object.keys(node);
-    }
-    else if (isObject.check(node)) {
-        names = types.getFieldNames(node);
-    }
-    else {
-        return;
-    }
-    if (!resultArray) {
-        Object.defineProperty(node, childNodesCacheKey, {
-            value: resultArray = [],
-            enumerable: false
-        });
-    }
-    for (var i = 0, nameCount = names.length; i < nameCount; ++i) {
-        getSortedChildNodes(node[names[i]], lines, resultArray);
-    }
-    return resultArray;
-}
-// As efficiently as possible, decorate the comment object with
-// .precedingNode, .enclosingNode, and/or .followingNode properties, at
-// least one of which is guaranteed to be defined.
-function decorateComment(node, comment, lines) {
-    var childNodes = getSortedChildNodes(node, lines);
-    // Time to dust off the old binary search robes and wizard hat.
-    var left = 0, right = childNodes.length;
-    while (left < right) {
-        var middle = (left + right) >> 1;
-        var child = childNodes[middle];
-        if (util_1.comparePos(child.loc.start, comment.loc.start) <= 0 &&
-            util_1.comparePos(comment.loc.end, child.loc.end) <= 0) {
-            // The comment is completely contained by this child node.
-            decorateComment(comment.enclosingNode = child, comment, lines);
-            return; // Abandon the binary search at this level.
-        }
-        if (util_1.comparePos(child.loc.end, comment.loc.start) <= 0) {
-            // This child node falls completely before the comment.
-            // Because we will never consider this node or any nodes
-            // before it again, this node must be the closest preceding
-            // node we have encountered so far.
-            var precedingNode = child;
-            left = middle + 1;
-            continue;
-        }
-        if (util_1.comparePos(comment.loc.end, child.loc.start) <= 0) {
-            // This child node falls completely after the comment.
-            // Because we will never consider this node or any nodes after
-            // it again, this node must be the closest following node we
-            // have encountered so far.
-            var followingNode = child;
-            right = middle;
-            continue;
-        }
-        throw new Error("Comment location overlaps with node location");
-    }
-    if (precedingNode) {
-        comment.precedingNode = precedingNode;
-    }
-    if (followingNode) {
-        comment.followingNode = followingNode;
-    }
-}
-function attach(comments, ast, lines) {
-    if (!isArray.check(comments)) {
-        return;
-    }
-    var tiesToBreak = [];
-    comments.forEach(function (comment) {
-        comment.loc.lines = lines;
-        decorateComment(ast, comment, lines);
-        var pn = comment.precedingNode;
-        var en = comment.enclosingNode;
-        var fn = comment.followingNode;
-        if (pn && fn) {
-            var tieCount = tiesToBreak.length;
-            if (tieCount > 0) {
-                var lastTie = tiesToBreak[tieCount - 1];
-                assert_1.default.strictEqual(lastTie.precedingNode === comment.precedingNode, lastTie.followingNode === comment.followingNode);
-                if (lastTie.followingNode !== comment.followingNode) {
-                    breakTies(tiesToBreak, lines);
-                }
-            }
-            tiesToBreak.push(comment);
-        }
-        else if (pn) {
-            // No contest: we have a trailing comment.
-            breakTies(tiesToBreak, lines);
-            addTrailingComment(pn, comment);
-        }
-        else if (fn) {
-            // No contest: we have a leading comment.
-            breakTies(tiesToBreak, lines);
-            addLeadingComment(fn, comment);
-        }
-        else if (en) {
-            // The enclosing node has no child nodes at all, so what we
-            // have here is a dangling comment, e.g. [/* crickets */].
-            breakTies(tiesToBreak, lines);
-            addDanglingComment(en, comment);
-        }
-        else {
-            throw new Error("AST contains no nodes at all?");
-        }
-    });
-    breakTies(tiesToBreak, lines);
-    comments.forEach(function (comment) {
-        // These node references were useful for breaking ties, but we
-        // don't need them anymore, and they create cycles in the AST that
-        // may lead to infinite recursion if we don't delete them here.
-        delete comment.precedingNode;
-        delete comment.enclosingNode;
-        delete comment.followingNode;
-    });
-}
-exports.attach = attach;
-;
-function breakTies(tiesToBreak, lines) {
-    var tieCount = tiesToBreak.length;
-    if (tieCount === 0) {
-        return;
-    }
-    var pn = tiesToBreak[0].precedingNode;
-    var fn = tiesToBreak[0].followingNode;
-    var gapEndPos = fn.loc.start;
-    // Iterate backwards through tiesToBreak, examining the gaps
-    // between the tied comments. In order to qualify as leading, a
-    // comment must be separated from fn by an unbroken series of
-    // whitespace-only gaps (or other comments).
-    for (var indexOfFirstLeadingComment = tieCount; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
-        var comment = tiesToBreak[indexOfFirstLeadingComment - 1];
-        assert_1.default.strictEqual(comment.precedingNode, pn);
-        assert_1.default.strictEqual(comment.followingNode, fn);
-        var gap = lines.sliceString(comment.loc.end, gapEndPos);
-        if (/\S/.test(gap)) {
-            // The gap string contained something other than whitespace.
-            break;
-        }
-        gapEndPos = comment.loc.start;
-    }
-    while (indexOfFirstLeadingComment <= tieCount &&
-        (comment = tiesToBreak[indexOfFirstLeadingComment]) &&
-        // If the comment is a //-style comment and indented more
-        // deeply than the node itself, reconsider it as trailing.
-        (comment.type === "Line" || comment.type === "CommentLine") &&
-        comment.loc.start.column > fn.loc.start.column) {
-        ++indexOfFirstLeadingComment;
-    }
-    tiesToBreak.forEach(function (comment, i) {
-        if (i < indexOfFirstLeadingComment) {
-            addTrailingComment(pn, comment);
-        }
-        else {
-            addLeadingComment(fn, comment);
-        }
-    });
-    tiesToBreak.length = 0;
-}
-function addCommentHelper(node, comment) {
-    var comments = node.comments || (node.comments = []);
-    comments.push(comment);
-}
-function addLeadingComment(node, comment) {
-    comment.leading = true;
-    comment.trailing = false;
-    addCommentHelper(node, comment);
-}
-function addDanglingComment(node, comment) {
-    comment.leading = false;
-    comment.trailing = false;
-    addCommentHelper(node, comment);
-}
-function addTrailingComment(node, comment) {
-    comment.leading = false;
-    comment.trailing = true;
-    addCommentHelper(node, comment);
-}
-function printLeadingComment(commentPath, print) {
-    var comment = commentPath.getValue();
-    n.Comment.assert(comment);
-    var loc = comment.loc;
-    var lines = loc && loc.lines;
-    var parts = [print(commentPath)];
-    if (comment.trailing) {
-        // When we print trailing comments as leading comments, we don't
-        // want to bring any trailing spaces along.
-        parts.push("\n");
-    }
-    else if (lines instanceof lines_1.Lines) {
-        var trailingSpace = lines.slice(loc.end, lines.skipSpaces(loc.end) || lines.lastPos());
-        if (trailingSpace.length === 1) {
-            // If the trailing space contains no newlines, then we want to
-            // preserve it exactly as we found it.
-            parts.push(trailingSpace);
-        }
-        else {
-            // If the trailing space contains newlines, then replace it
-            // with just that many newlines, with all other spaces removed.
-            parts.push(new Array(trailingSpace.length).join("\n"));
-        }
-    }
-    else {
-        parts.push("\n");
-    }
-    return lines_1.concat(parts);
-}
-function printTrailingComment(commentPath, print) {
-    var comment = commentPath.getValue(commentPath);
-    n.Comment.assert(comment);
-    var loc = comment.loc;
-    var lines = loc && loc.lines;
-    var parts = [];
-    if (lines instanceof lines_1.Lines) {
-        var fromPos = lines.skipSpaces(loc.start, true) || lines.firstPos();
-        var leadingSpace = lines.slice(fromPos, loc.start);
-        if (leadingSpace.length === 1) {
-            // If the leading space contains no newlines, then we want to
-            // preserve it exactly as we found it.
-            parts.push(leadingSpace);
-        }
-        else {
-            // If the leading space contains newlines, then replace it
-            // with just that many newlines, sans all other spaces.
-            parts.push(new Array(leadingSpace.length).join("\n"));
-        }
-    }
-    parts.push(print(commentPath));
-    return lines_1.concat(parts);
-}
-function printComments(path, print) {
-    var value = path.getValue();
-    var innerLines = print(path);
-    var comments = n.Node.check(value) &&
-        types.getFieldValue(value, "comments");
-    if (!comments || comments.length === 0) {
-        return innerLines;
-    }
-    var leadingParts = [];
-    var trailingParts = [innerLines];
-    path.each(function (commentPath) {
-        var comment = commentPath.getValue();
-        var leading = types.getFieldValue(comment, "leading");
-        var trailing = types.getFieldValue(comment, "trailing");
-        if (leading || (trailing && !(n.Statement.check(value) ||
-            comment.type === "Block" ||
-            comment.type === "CommentBlock"))) {
-            leadingParts.push(printLeadingComment(commentPath, print));
-        }
-        else if (trailing) {
-            trailingParts.push(printTrailingComment(commentPath, print));
-        }
-    }, "comments");
-    leadingParts.push.apply(leadingParts, trailingParts);
-    return lines_1.concat(leadingParts);
-}
-exports.printComments = printComments;
-;