| "use strict"; |
| |
| exports.__esModule = true; |
| exports.createTypeAnnotationBasedOnTypeof = exports.removeTypeDuplicates = exports.createUnionTypeAnnotation = exports.valueToNode = exports.toBlock = exports.toExpression = exports.toStatement = exports.toBindingIdentifierName = exports.toIdentifier = exports.toKeyAlias = exports.toSequenceExpression = exports.toComputedKey = exports.isNodesEquivalent = exports.isImmutable = exports.isScope = exports.isSpecifierDefault = exports.isVar = exports.isBlockScoped = exports.isLet = exports.isValidIdentifier = exports.isReferenced = exports.isBinding = exports.getOuterBindingIdentifiers = exports.getBindingIdentifiers = exports.TYPES = exports.react = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = undefined; |
| |
| var _getOwnPropertySymbols = require("babel-runtime/core-js/object/get-own-property-symbols"); |
| |
| var _getOwnPropertySymbols2 = _interopRequireDefault(_getOwnPropertySymbols); |
| |
| var _getIterator2 = require("babel-runtime/core-js/get-iterator"); |
| |
| var _getIterator3 = _interopRequireDefault(_getIterator2); |
| |
| var _keys = require("babel-runtime/core-js/object/keys"); |
| |
| var _keys2 = _interopRequireDefault(_keys); |
| |
| var _stringify = require("babel-runtime/core-js/json/stringify"); |
| |
| var _stringify2 = _interopRequireDefault(_stringify); |
| |
| var _constants = require("./constants"); |
| |
| Object.defineProperty(exports, "STATEMENT_OR_BLOCK_KEYS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.STATEMENT_OR_BLOCK_KEYS; |
| } |
| }); |
| Object.defineProperty(exports, "FLATTENABLE_KEYS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.FLATTENABLE_KEYS; |
| } |
| }); |
| Object.defineProperty(exports, "FOR_INIT_KEYS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.FOR_INIT_KEYS; |
| } |
| }); |
| Object.defineProperty(exports, "COMMENT_KEYS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.COMMENT_KEYS; |
| } |
| }); |
| Object.defineProperty(exports, "LOGICAL_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.LOGICAL_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "UPDATE_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.UPDATE_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "BOOLEAN_NUMBER_BINARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.BOOLEAN_NUMBER_BINARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "EQUALITY_BINARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.EQUALITY_BINARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "COMPARISON_BINARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.COMPARISON_BINARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "BOOLEAN_BINARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.BOOLEAN_BINARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "NUMBER_BINARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.NUMBER_BINARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "BINARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.BINARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "BOOLEAN_UNARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.BOOLEAN_UNARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "NUMBER_UNARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.NUMBER_UNARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "STRING_UNARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.STRING_UNARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "UNARY_OPERATORS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.UNARY_OPERATORS; |
| } |
| }); |
| Object.defineProperty(exports, "INHERIT_KEYS", { |
| enumerable: true, |
| get: function get() { |
| return _constants.INHERIT_KEYS; |
| } |
| }); |
| Object.defineProperty(exports, "BLOCK_SCOPED_SYMBOL", { |
| enumerable: true, |
| get: function get() { |
| return _constants.BLOCK_SCOPED_SYMBOL; |
| } |
| }); |
| Object.defineProperty(exports, "NOT_LOCAL_BINDING", { |
| enumerable: true, |
| get: function get() { |
| return _constants.NOT_LOCAL_BINDING; |
| } |
| }); |
| exports.is = is; |
| exports.isType = isType; |
| exports.validate = validate; |
| exports.shallowEqual = shallowEqual; |
| exports.appendToMemberExpression = appendToMemberExpression; |
| exports.prependToMemberExpression = prependToMemberExpression; |
| exports.ensureBlock = ensureBlock; |
| exports.clone = clone; |
| exports.cloneWithoutLoc = cloneWithoutLoc; |
| exports.cloneDeep = cloneDeep; |
| exports.buildMatchMemberExpression = buildMatchMemberExpression; |
| exports.removeComments = removeComments; |
| exports.inheritsComments = inheritsComments; |
| exports.inheritTrailingComments = inheritTrailingComments; |
| exports.inheritLeadingComments = inheritLeadingComments; |
| exports.inheritInnerComments = inheritInnerComments; |
| exports.inherits = inherits; |
| exports.assertNode = assertNode; |
| exports.isNode = isNode; |
| exports.traverseFast = traverseFast; |
| exports.removeProperties = removeProperties; |
| exports.removePropertiesDeep = removePropertiesDeep; |
| |
| var _retrievers = require("./retrievers"); |
| |
| Object.defineProperty(exports, "getBindingIdentifiers", { |
| enumerable: true, |
| get: function get() { |
| return _retrievers.getBindingIdentifiers; |
| } |
| }); |
| Object.defineProperty(exports, "getOuterBindingIdentifiers", { |
| enumerable: true, |
| get: function get() { |
| return _retrievers.getOuterBindingIdentifiers; |
| } |
| }); |
| |
| var _validators = require("./validators"); |
| |
| Object.defineProperty(exports, "isBinding", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isBinding; |
| } |
| }); |
| Object.defineProperty(exports, "isReferenced", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isReferenced; |
| } |
| }); |
| Object.defineProperty(exports, "isValidIdentifier", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isValidIdentifier; |
| } |
| }); |
| Object.defineProperty(exports, "isLet", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isLet; |
| } |
| }); |
| Object.defineProperty(exports, "isBlockScoped", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isBlockScoped; |
| } |
| }); |
| Object.defineProperty(exports, "isVar", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isVar; |
| } |
| }); |
| Object.defineProperty(exports, "isSpecifierDefault", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isSpecifierDefault; |
| } |
| }); |
| Object.defineProperty(exports, "isScope", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isScope; |
| } |
| }); |
| Object.defineProperty(exports, "isImmutable", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isImmutable; |
| } |
| }); |
| Object.defineProperty(exports, "isNodesEquivalent", { |
| enumerable: true, |
| get: function get() { |
| return _validators.isNodesEquivalent; |
| } |
| }); |
| |
| var _converters = require("./converters"); |
| |
| Object.defineProperty(exports, "toComputedKey", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toComputedKey; |
| } |
| }); |
| Object.defineProperty(exports, "toSequenceExpression", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toSequenceExpression; |
| } |
| }); |
| Object.defineProperty(exports, "toKeyAlias", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toKeyAlias; |
| } |
| }); |
| Object.defineProperty(exports, "toIdentifier", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toIdentifier; |
| } |
| }); |
| Object.defineProperty(exports, "toBindingIdentifierName", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toBindingIdentifierName; |
| } |
| }); |
| Object.defineProperty(exports, "toStatement", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toStatement; |
| } |
| }); |
| Object.defineProperty(exports, "toExpression", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toExpression; |
| } |
| }); |
| Object.defineProperty(exports, "toBlock", { |
| enumerable: true, |
| get: function get() { |
| return _converters.toBlock; |
| } |
| }); |
| Object.defineProperty(exports, "valueToNode", { |
| enumerable: true, |
| get: function get() { |
| return _converters.valueToNode; |
| } |
| }); |
| |
| var _flow = require("./flow"); |
| |
| Object.defineProperty(exports, "createUnionTypeAnnotation", { |
| enumerable: true, |
| get: function get() { |
| return _flow.createUnionTypeAnnotation; |
| } |
| }); |
| Object.defineProperty(exports, "removeTypeDuplicates", { |
| enumerable: true, |
| get: function get() { |
| return _flow.removeTypeDuplicates; |
| } |
| }); |
| Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", { |
| enumerable: true, |
| get: function get() { |
| return _flow.createTypeAnnotationBasedOnTypeof; |
| } |
| }); |
| |
| var _toFastProperties = require("to-fast-properties"); |
| |
| var _toFastProperties2 = _interopRequireDefault(_toFastProperties); |
| |
| var _clone = require("lodash/clone"); |
| |
| var _clone2 = _interopRequireDefault(_clone); |
| |
| var _uniq = require("lodash/uniq"); |
| |
| var _uniq2 = _interopRequireDefault(_uniq); |
| |
| require("./definitions/init"); |
| |
| var _definitions = require("./definitions"); |
| |
| var _react2 = require("./react"); |
| |
| var _react = _interopRequireWildcard(_react2); |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| var t = exports; |
| |
| function registerType(type) { |
| var is = t["is" + type]; |
| if (!is) { |
| is = t["is" + type] = function (node, opts) { |
| return t.is(type, node, opts); |
| }; |
| } |
| |
| t["assert" + type] = function (node, opts) { |
| opts = opts || {}; |
| if (!is(node, opts)) { |
| throw new Error("Expected type " + (0, _stringify2.default)(type) + " with option " + (0, _stringify2.default)(opts)); |
| } |
| }; |
| } |
| |
| exports.VISITOR_KEYS = _definitions.VISITOR_KEYS; |
| exports.ALIAS_KEYS = _definitions.ALIAS_KEYS; |
| exports.NODE_FIELDS = _definitions.NODE_FIELDS; |
| exports.BUILDER_KEYS = _definitions.BUILDER_KEYS; |
| exports.DEPRECATED_KEYS = _definitions.DEPRECATED_KEYS; |
| exports.react = _react; |
| |
| |
| for (var type in t.VISITOR_KEYS) { |
| registerType(type); |
| } |
| |
| t.FLIPPED_ALIAS_KEYS = {}; |
| |
| (0, _keys2.default)(t.ALIAS_KEYS).forEach(function (type) { |
| t.ALIAS_KEYS[type].forEach(function (alias) { |
| var types = t.FLIPPED_ALIAS_KEYS[alias] = t.FLIPPED_ALIAS_KEYS[alias] || []; |
| types.push(type); |
| }); |
| }); |
| |
| (0, _keys2.default)(t.FLIPPED_ALIAS_KEYS).forEach(function (type) { |
| t[type.toUpperCase() + "_TYPES"] = t.FLIPPED_ALIAS_KEYS[type]; |
| registerType(type); |
| }); |
| |
| var TYPES = exports.TYPES = (0, _keys2.default)(t.VISITOR_KEYS).concat((0, _keys2.default)(t.FLIPPED_ALIAS_KEYS)).concat((0, _keys2.default)(t.DEPRECATED_KEYS)); |
| |
| function is(type, node, opts) { |
| if (!node) return false; |
| |
| var matches = isType(node.type, type); |
| if (!matches) return false; |
| |
| if (typeof opts === "undefined") { |
| return true; |
| } else { |
| return t.shallowEqual(node, opts); |
| } |
| } |
| |
| function isType(nodeType, targetType) { |
| if (nodeType === targetType) return true; |
| |
| if (t.ALIAS_KEYS[targetType]) return false; |
| |
| var aliases = t.FLIPPED_ALIAS_KEYS[targetType]; |
| if (aliases) { |
| if (aliases[0] === nodeType) return true; |
| |
| for (var _iterator = aliases, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) { |
| var _ref; |
| |
| if (_isArray) { |
| if (_i >= _iterator.length) break; |
| _ref = _iterator[_i++]; |
| } else { |
| _i = _iterator.next(); |
| if (_i.done) break; |
| _ref = _i.value; |
| } |
| |
| var alias = _ref; |
| |
| if (nodeType === alias) return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| (0, _keys2.default)(t.BUILDER_KEYS).forEach(function (type) { |
| var keys = t.BUILDER_KEYS[type]; |
| |
| function builder() { |
| if (arguments.length > keys.length) { |
| throw new Error("t." + type + ": Too many arguments passed. Received " + arguments.length + " but can receive " + ("no more than " + keys.length)); |
| } |
| |
| var node = {}; |
| node.type = type; |
| |
| var i = 0; |
| |
| for (var _iterator2 = keys, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) { |
| var _ref2; |
| |
| if (_isArray2) { |
| if (_i2 >= _iterator2.length) break; |
| _ref2 = _iterator2[_i2++]; |
| } else { |
| _i2 = _iterator2.next(); |
| if (_i2.done) break; |
| _ref2 = _i2.value; |
| } |
| |
| var _key = _ref2; |
| |
| var field = t.NODE_FIELDS[type][_key]; |
| |
| var arg = arguments[i++]; |
| if (arg === undefined) arg = (0, _clone2.default)(field.default); |
| |
| node[_key] = arg; |
| } |
| |
| for (var key in node) { |
| validate(node, key, node[key]); |
| } |
| |
| return node; |
| } |
| |
| t[type] = builder; |
| t[type[0].toLowerCase() + type.slice(1)] = builder; |
| }); |
| |
| var _loop = function _loop(_type) { |
| var newType = t.DEPRECATED_KEYS[_type]; |
| |
| function proxy(fn) { |
| return function () { |
| console.trace("The node type " + _type + " has been renamed to " + newType); |
| return fn.apply(this, arguments); |
| }; |
| } |
| |
| t[_type] = t[_type[0].toLowerCase() + _type.slice(1)] = proxy(t[newType]); |
| t["is" + _type] = proxy(t["is" + newType]); |
| t["assert" + _type] = proxy(t["assert" + newType]); |
| }; |
| |
| for (var _type in t.DEPRECATED_KEYS) { |
| _loop(_type); |
| } |
| |
| function validate(node, key, val) { |
| if (!node) return; |
| |
| var fields = t.NODE_FIELDS[node.type]; |
| if (!fields) return; |
| |
| var field = fields[key]; |
| if (!field || !field.validate) return; |
| if (field.optional && val == null) return; |
| |
| field.validate(node, key, val); |
| } |
| |
| function shallowEqual(actual, expected) { |
| var keys = (0, _keys2.default)(expected); |
| |
| for (var _iterator3 = keys, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) { |
| var _ref3; |
| |
| if (_isArray3) { |
| if (_i3 >= _iterator3.length) break; |
| _ref3 = _iterator3[_i3++]; |
| } else { |
| _i3 = _iterator3.next(); |
| if (_i3.done) break; |
| _ref3 = _i3.value; |
| } |
| |
| var key = _ref3; |
| |
| if (actual[key] !== expected[key]) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| function appendToMemberExpression(member, append, computed) { |
| member.object = t.memberExpression(member.object, member.property, member.computed); |
| member.property = append; |
| member.computed = !!computed; |
| return member; |
| } |
| |
| function prependToMemberExpression(member, prepend) { |
| member.object = t.memberExpression(prepend, member.object); |
| return member; |
| } |
| |
| function ensureBlock(node) { |
| var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "body"; |
| |
| return node[key] = t.toBlock(node[key], node); |
| } |
| |
| function clone(node) { |
| if (!node) return node; |
| var newNode = {}; |
| for (var key in node) { |
| if (key[0] === "_") continue; |
| newNode[key] = node[key]; |
| } |
| return newNode; |
| } |
| |
| function cloneWithoutLoc(node) { |
| var newNode = clone(node); |
| delete newNode.loc; |
| return newNode; |
| } |
| |
| function cloneDeep(node) { |
| if (!node) return node; |
| var newNode = {}; |
| |
| for (var key in node) { |
| if (key[0] === "_") continue; |
| |
| var val = node[key]; |
| |
| if (val) { |
| if (val.type) { |
| val = t.cloneDeep(val); |
| } else if (Array.isArray(val)) { |
| val = val.map(t.cloneDeep); |
| } |
| } |
| |
| newNode[key] = val; |
| } |
| |
| return newNode; |
| } |
| |
| function buildMatchMemberExpression(match, allowPartial) { |
| var parts = match.split("."); |
| |
| return function (member) { |
| if (!t.isMemberExpression(member)) return false; |
| |
| var search = [member]; |
| var i = 0; |
| |
| while (search.length) { |
| var node = search.shift(); |
| |
| if (allowPartial && i === parts.length) { |
| return true; |
| } |
| |
| if (t.isIdentifier(node)) { |
| if (parts[i] !== node.name) return false; |
| } else if (t.isStringLiteral(node)) { |
| if (parts[i] !== node.value) return false; |
| } else if (t.isMemberExpression(node)) { |
| if (node.computed && !t.isStringLiteral(node.property)) { |
| return false; |
| } else { |
| search.push(node.object); |
| search.push(node.property); |
| continue; |
| } |
| } else { |
| return false; |
| } |
| |
| if (++i > parts.length) { |
| return false; |
| } |
| } |
| |
| return true; |
| }; |
| } |
| |
| function removeComments(node) { |
| for (var _iterator4 = t.COMMENT_KEYS, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) { |
| var _ref4; |
| |
| if (_isArray4) { |
| if (_i4 >= _iterator4.length) break; |
| _ref4 = _iterator4[_i4++]; |
| } else { |
| _i4 = _iterator4.next(); |
| if (_i4.done) break; |
| _ref4 = _i4.value; |
| } |
| |
| var key = _ref4; |
| |
| delete node[key]; |
| } |
| return node; |
| } |
| |
| function inheritsComments(child, parent) { |
| inheritTrailingComments(child, parent); |
| inheritLeadingComments(child, parent); |
| inheritInnerComments(child, parent); |
| return child; |
| } |
| |
| function inheritTrailingComments(child, parent) { |
| _inheritComments("trailingComments", child, parent); |
| } |
| |
| function inheritLeadingComments(child, parent) { |
| _inheritComments("leadingComments", child, parent); |
| } |
| |
| function inheritInnerComments(child, parent) { |
| _inheritComments("innerComments", child, parent); |
| } |
| |
| function _inheritComments(key, child, parent) { |
| if (child && parent) { |
| child[key] = (0, _uniq2.default)([].concat(child[key], parent[key]).filter(Boolean)); |
| } |
| } |
| |
| function inherits(child, parent) { |
| if (!child || !parent) return child; |
| |
| for (var _iterator5 = t.INHERIT_KEYS.optional, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : (0, _getIterator3.default)(_iterator5);;) { |
| var _ref5; |
| |
| if (_isArray5) { |
| if (_i5 >= _iterator5.length) break; |
| _ref5 = _iterator5[_i5++]; |
| } else { |
| _i5 = _iterator5.next(); |
| if (_i5.done) break; |
| _ref5 = _i5.value; |
| } |
| |
| var _key2 = _ref5; |
| |
| if (child[_key2] == null) { |
| child[_key2] = parent[_key2]; |
| } |
| } |
| |
| for (var key in parent) { |
| if (key[0] === "_") child[key] = parent[key]; |
| } |
| |
| for (var _iterator6 = t.INHERIT_KEYS.force, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : (0, _getIterator3.default)(_iterator6);;) { |
| var _ref6; |
| |
| if (_isArray6) { |
| if (_i6 >= _iterator6.length) break; |
| _ref6 = _iterator6[_i6++]; |
| } else { |
| _i6 = _iterator6.next(); |
| if (_i6.done) break; |
| _ref6 = _i6.value; |
| } |
| |
| var _key3 = _ref6; |
| |
| child[_key3] = parent[_key3]; |
| } |
| |
| t.inheritsComments(child, parent); |
| |
| return child; |
| } |
| |
| function assertNode(node) { |
| if (!isNode(node)) { |
| throw new TypeError("Not a valid node " + (node && node.type)); |
| } |
| } |
| |
| function isNode(node) { |
| return !!(node && _definitions.VISITOR_KEYS[node.type]); |
| } |
| |
| (0, _toFastProperties2.default)(t); |
| (0, _toFastProperties2.default)(t.VISITOR_KEYS); |
| |
| function traverseFast(node, enter, opts) { |
| if (!node) return; |
| |
| var keys = t.VISITOR_KEYS[node.type]; |
| if (!keys) return; |
| |
| opts = opts || {}; |
| enter(node, opts); |
| |
| for (var _iterator7 = keys, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : (0, _getIterator3.default)(_iterator7);;) { |
| var _ref7; |
| |
| if (_isArray7) { |
| if (_i7 >= _iterator7.length) break; |
| _ref7 = _iterator7[_i7++]; |
| } else { |
| _i7 = _iterator7.next(); |
| if (_i7.done) break; |
| _ref7 = _i7.value; |
| } |
| |
| var key = _ref7; |
| |
| var subNode = node[key]; |
| |
| if (Array.isArray(subNode)) { |
| for (var _iterator8 = subNode, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : (0, _getIterator3.default)(_iterator8);;) { |
| var _ref8; |
| |
| if (_isArray8) { |
| if (_i8 >= _iterator8.length) break; |
| _ref8 = _iterator8[_i8++]; |
| } else { |
| _i8 = _iterator8.next(); |
| if (_i8.done) break; |
| _ref8 = _i8.value; |
| } |
| |
| var _node = _ref8; |
| |
| traverseFast(_node, enter, opts); |
| } |
| } else { |
| traverseFast(subNode, enter, opts); |
| } |
| } |
| } |
| |
| var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"]; |
| |
| var CLEAR_KEYS_PLUS_COMMENTS = t.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS); |
| |
| function removeProperties(node, opts) { |
| opts = opts || {}; |
| var map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS; |
| for (var _iterator9 = map, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : (0, _getIterator3.default)(_iterator9);;) { |
| var _ref9; |
| |
| if (_isArray9) { |
| if (_i9 >= _iterator9.length) break; |
| _ref9 = _iterator9[_i9++]; |
| } else { |
| _i9 = _iterator9.next(); |
| if (_i9.done) break; |
| _ref9 = _i9.value; |
| } |
| |
| var _key4 = _ref9; |
| |
| if (node[_key4] != null) node[_key4] = undefined; |
| } |
| |
| for (var key in node) { |
| if (key[0] === "_" && node[key] != null) node[key] = undefined; |
| } |
| |
| var syms = (0, _getOwnPropertySymbols2.default)(node); |
| for (var _iterator10 = syms, _isArray10 = Array.isArray(_iterator10), _i10 = 0, _iterator10 = _isArray10 ? _iterator10 : (0, _getIterator3.default)(_iterator10);;) { |
| var _ref10; |
| |
| if (_isArray10) { |
| if (_i10 >= _iterator10.length) break; |
| _ref10 = _iterator10[_i10++]; |
| } else { |
| _i10 = _iterator10.next(); |
| if (_i10.done) break; |
| _ref10 = _i10.value; |
| } |
| |
| var sym = _ref10; |
| |
| node[sym] = null; |
| } |
| } |
| |
| function removePropertiesDeep(tree, opts) { |
| traverseFast(tree, removeProperties, opts); |
| return tree; |
| } |