react-mobiscroll
Version:
A simple wrapper of Mobiscroll for ReactJS.
1,385 lines (1,198 loc) • 1.56 MB
JavaScript
require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
(function (process){
'use strict';
var diagnostics = process.env.BROWSERIFYSHIM_DIAGNOSTICS;
function inspect(obj, depth) {
return require('util').inspect(obj, false, depth || 5, true);
}
exports = module.exports = function debug() {
if (diagnostics) console.error.apply(console, arguments);
}
exports.inspect = function(obj, depth) {
if (diagnostics) console.error(inspect(obj, depth));
}
}).call(this,require('_process'))
},{"_process":87,"util":102}],2:[function(require,module,exports){
'use strict';
function parseDepends(deps) {
if (!deps) return undefined;
// allow depends: [ '..' ] and depends: '..'
deps = Array.isArray(deps) ? deps : [ deps ];
return deps
.reduce(function (acc, d) {
var parts = d.split(':');
if (!parts
|| parts.length > 2
|| parts.length < 1
|| !parts[0])
throw new Error('Invalid depends specification: "' + d + '". Needs to have format: "nameORpath:export"');
parts = parts.map(function (p) {
return typeof p === 'string' ? p.trim() : p
});
// if parts[1] is not defined that means that we depend on module named in parts[0]
// but we don't need it to be attached to the window under a certain name
acc[parts[0]] = parts[1] || null;
return acc;
}, {});
}
/**
* Parses inlined shims-config and returns a config in the same format that is used by external shims
*
* Example:
*
* Given:
* { jquery: '$',
* 'non-cjs': 'noncjs',
* 'non-cjs-dep': { exports: 'noncjsdep', depends: 'non-cjs:noncjs' },
* 'just-dep': { exports: 'justdep', depends: [ 'non-cjs:noncjs', 'jquery:$' ] }
* }
*
* returns:
* { jquery: { exports: '$', depends: undefined },
* 'non-cjs': { exports: 'noncjs', depends: undefined },
* 'non-cjs-dep': { exports: 'noncjsdep', depends: { 'non-cjs': 'noncjs' } },
* 'just-dep': { exports: 'justdep', depends: { 'non-cjs': 'noncjs', jquery: '$' } }
* }
*
* @name parseInlineShims
* @function
* @param {Object} config inlined shims config
* @return {Object} parsed config
*/
var go = module.exports = function (config) {
// all errors thrown are caught inside resolve-shims and passed back to browserify-shim
return Object.keys(config)
.reduce(function (acc, field) {
var conf = config[field];
// normalize two possible formats:
// "key": "export,
// "key": { "exports": "export" .. }
if (typeof conf === 'string') conf = { exports: conf };
var exps = conf.exports && conf.exports.length ? conf.exports.trim() : null;
acc[field.trim()] = {
exports: exps
, depends: parseDepends(conf.depends)
}
return acc;
}, {});
}
},{}],3:[function(require,module,exports){
'use strict';
var path = require('path')
, fs = require('fs')
, util = require('util')
, parseInlineShims = require('./parse-inline-shims')
, mothership = require('mothership')
, format = require('util').format
var shimsCache = {}
, shimsByPath = {};
function inspect(obj, depth) {
return util.inspect(obj, false, depth || 5, true);
}
function isPath(s) {
return (/^[.]{0,2}[/\\]/).test(s);
}
function validate(key, config, dir) {
var msg
, details = 'When evaluating shim "' + key + '": ' + inspect(config) + '\ninside ' + dir + '\n';
if (!config.hasOwnProperty('exports')) {
msg = 'browserify-shim needs at least a path and exports to do its job, you are missing the exports. ' +
'\nIf this module has no exports, specify exports as null.'
throw new Error(details + msg);
}
}
function updateCache(packageDir, pack, resolvedShims, exposeGlobals) {
shimsCache[packageDir] = { pack: pack, shims: resolvedShims, exposeGlobals: exposeGlobals };
Object.keys(resolvedShims).forEach(function(fullPath) {
var shim = resolvedShims[fullPath];
validate(fullPath, shim, packageDir);
shimsByPath[fullPath] = shim;
});
}
function resolveDependsRelativeTo(dir, browser, depends, packDeps, messages) {
var resolved;
if (!depends) return undefined;
return Object.keys(depends).reduce(function (acc, k) {
if (browser[k]){
acc[k] = depends[k];
messages.push(format('Found depends "%s" exposed in browser field', k));
} else if (!isPath(k)) {
acc[k] = depends[k];
if (packDeps[k]) {
messages.push(format('Found depends "%s" as an installed dependency of the package', k));
} else {
messages.push(format('WARNING, depends "%s" is not a path, nor is it exposed in the browser field, nor was it found in package dependencies.', k));
}
} else {
// otherwise resolve the path
resolved = path.resolve(dir, k);
acc[resolved] = depends[k];
messages.push(format('Depends "%s" was resolved to be at [%s]', k, resolved));
}
return acc;
}, {})
}
function resolvePaths (packageDir, shimFileDir, browser, shims, packDeps, messages) {
return Object.keys(shims)
.reduce(function (acc, relPath) {
var shim = shims[relPath];
var exposed = browser[relPath];
var shimPath;
if (exposed) {
// lib exposed under different name/path in package.json's browser field
// and it is referred to by this alias in the shims (either external or in package.json)
// i.e.: 'non-cjs': { ... } -> browser: { 'non-cjs': './vendor/non-cjs.js }
shimPath = path.resolve(packageDir, exposed);
messages.push(format('Found "%s" in browser field referencing "%s" and resolved it to "%s"', relPath, exposed, shimPath));
} else if (shimFileDir) {
// specified via relative path to shim file inside shim file
// i.e. './vendor/non-cjs': { exports: .. }
shimPath = path.resolve(shimFileDir, relPath);
messages.push(format('Resolved "%s" found in shim file to "%s"', relPath, shimPath));
} else {
// specified via relative path in package.json browserify-shim config
// i.e. 'browserify-shim': { './vendor/non-cjs': 'noncjs' }
shimPath = path.resolve(packageDir, relPath);
messages.push(format('Resolved "%s" found in package.json to "%s"', relPath, shimPath));
}
var depends = resolveDependsRelativeTo(shimFileDir || packageDir, browser, shim.depends, packDeps, messages);
acc[shimPath] = { exports: shim.exports, depends: depends };
return acc;
}, {});
}
function mapifyExposeGlobals(exposeGlobals) {
return Object.keys(exposeGlobals)
.reduce(function (acc, k) {
var val = exposeGlobals[k];
var parts = val.split(':');
if (parts.length < 2 || !parts[1].length) {
throw new Error(
'Expose Globals need to have the format "global:expression.\n"'
+ inspect({ key: k, value: val }) + 'does not.'
);
}
// this also handle unlikely cases of 'global:_.someFunc(':')' with a `:` in the actual global expression
parts.shift();
acc[k] = parts.join(':');
return acc;
}, {});
}
function separateExposeGlobals(shims) {
var onlyShims = {}
, exposeGlobals = {};
Object.keys(shims).forEach(function (k) {
var val = shims[k]
, exp = val && val.exports;
if (exp && /^global\:/.test(exp)) {
exposeGlobals[k] = exp;
} else {
onlyShims[k] = val;
}
});
return { shims: onlyShims, exposeGlobals: mapifyExposeGlobals(exposeGlobals) };
}
function resolveFromShimFile(packageDir, pack, shimField, messages) {
var shimFile = path.join(packageDir, shimField)
, shimFileDir = path.dirname(shimFile);
var allShims = require(shimFile);
var separated = separateExposeGlobals(allShims);
var resolvedShims = resolvePaths(packageDir, shimFileDir, pack.browser || {}, separated.shims, pack.dependencies || {}, messages);
return { shims: resolvedShims, exposeGlobals: separated.exposeGlobals };
}
function resolveInlineShims(packageDir, pack, shimField, messages) {
var allShims = parseInlineShims(shimField);
var separated = separateExposeGlobals(allShims);
var resolvedShims = resolvePaths(packageDir, null, pack.browser || {}, separated.shims, pack.dependencies || {}, messages);
return { shims: resolvedShims, exposeGlobals: separated.exposeGlobals };
}
var resolve = module.exports = function resolveShims (file, messages, cb) {
// find the package.json that defines browserify-shim config for this file
mothership(file, function (pack) { return !! pack['browserify-shim'] }, function (err, res) {
if (err) return cb(err);
if (!res || !res.pack) return cb(new Error('Unable to find a browserify-shim config section in the package.json for ' + file));
var pack = res.pack;
var packFile = res.path;
var packageDir = path.dirname(packFile);
// we cached this before which means it was also grouped by file
var cached = shimsCache[packageDir];
// if it was cached, that means any package fixes were applied as well
if (cached) {
return cb(null, {
package_json : packFile
, packageDir : packageDir
, resolvedPreviously : true
, shim : shimsByPath[file]
, exposeGlobals : cached.exposeGlobals
, browser : pack.browser
, 'browserify-shim' : pack['browserify-shim']
, dependencies : pack.dependencies
});
}
try {
pack = require(packFile);
var shimField = pack['browserify-shim'];
if (!shimField) return cb(null, { package_json: packFile, shim: undefined });
var resolved = typeof shimField === 'string'
? resolveFromShimFile(packageDir, pack, shimField, messages)
: resolveInlineShims(packageDir, pack, shimField, messages);
messages.push({ resolved: resolved.shims });
updateCache(packageDir, pack, resolved.shims, resolved.exposeGlobals);
cb(null, {
package_json : packFile
, packageDir : packageDir
, shim : shimsByPath[file]
, exposeGlobals : resolved.exposeGlobals
, browser : pack.browser
, 'browserify-shim' : pack['browserify-shim']
, dependencies : pack.dependencies
});
} catch (err) {
console.trace();
return cb(err);
}
});
}
},{"./parse-inline-shims":2,"fs":77,"mothership":47,"path":86,"util":102}],4:[function(require,module,exports){
'use strict';
var detective = require('detective');
function rangeComparator(a, b) {
return a.from > b.from ? 1 : -1;
}
function getReplacements(id, globalVar, requires) {
if (!~requires.strings.indexOf(id)) return [];
var ranges = requires.strings
.reduce(function (acc, s, index) {
var node;
if (s === id) {
node = requires.nodes[index]
acc.push({ from: node.range[0], to: node.range[1], id: id, code: '(typeof window !== "undefined" ? window.' + globalVar + ' : typeof global !== "undefined" ? global.' + globalVar + ' : null)' });
}
return acc;
}, [])
return ranges;
}
function inspect(obj, depth) {
console.error(require('util').inspect(obj, false, depth || 5, true));
}
var go = module.exports =
/**
* Replaces each require statement for ids found in the map with an assignment to the global value.
*
* @name expose
* @private
* @function
* @param {Object.<string, string>} map maps module names to the global under which they are actually exposed
* @param {string} origSrc the original source
* @return {string} source with globals exposed
*/
function expose(map, origSrc) {
var regex, keys, id;
var src = origSrc;
keys = Object.keys(map);
// ensure that at least one of the require statements we want to replace is in the code
// before we perform the expensive operation of finding them by creating an AST
var hasMatchingRequires = keys.some(function (id) {
regex = new RegExp('require\\(\\s*[\'"]' + id + '[\'"]\\s*\\)');
return regex.test(src)
});
if (!hasMatchingRequires) return src;
var requires = detective.find(src, { nodes: true, parse: { range: true } });
if (!requires.strings.length) return src;
var replacements = keys
.reduce(function (acc, id) {
var r = getReplacements(id, map[id], requires);
return acc.concat(r);
}, [])
.sort(rangeComparator);
var offset = 0;
return replacements
.reduce(function(acc, replacement) {
var from = replacement.from + offset
, to = replacement.to + offset
, code = replacement.code;
// all ranges will be invalidated since we are changing the code
// therefore keep track of the offset to adjust them in case we replace multiple requires
var diff = code.length - (to - from);
offset += diff;
return acc.slice(0, from) + code + acc.slice(to);
}, src);
}
},{"detective":6,"util":102}],5:[function(require,module,exports){
(function (process){
'use strict';
var transformify = require('transformify')
, through = require('through2')
, expose = require('./expose');
exports = module.exports =
/**
* browserify transform which exposes globals as modules that can be required.
*
* @name exposify
* @function
* @param {string} file file whose content is to be transformed
* @return {TransformStream} transform that replaces require statements found in the code with global assigments
*/
function exposify(file) {
if (!exports.filePattern.test(file)) return through();
if (typeof exports.config !== 'object') {
throw new Error('Please set exposify.config or $EXPOSIFY_CONFIG so it knows what to expose');
}
var tx = transformify(expose.bind(null, exports.config));
return tx(file);
}
/**
* The config which is used by exposify to determine which require statemtents to replace and how.
* You need to set this or provide it via the `EXPOSIFY_CONFIG` environment variable.
*
* ### Example
*
* ```js
* // setting from javascript
* exposify.config = { jquery: '$', three: 'THREE' };
* ```
*
* ```sh
* # setting from command line
* EXPOSIFY_CONFIG='{ "jquery": "$", "three": "THREE" }' browserify -t exposify ...
* ```
*
* @name exposify::config
*
*/
exports.config = (function () {
if (process.env.EXPOSIFY_CONFIG) {
try {
return JSON.parse(process.env.EXPOSIFY_CONFIG);
} catch (err) {
console.error('Invalid exposify config!');
console.error(err.stack);
}
}
})();
/**
* Regex pattern of files whose content is exposified
*
* @name exposify::filePattern
*/
exports.filePattern = /\.js$/;
/**
* Exposes the expose function that operates on a string
*
* @name exposify::expose
*/
exports.expose = expose;
}).call(this,require('_process'))
},{"./expose":4,"_process":87,"through2":35,"transformify":36}],6:[function(require,module,exports){
var esprima = require('esprima');
var escodegen = require('escodegen');
var traverse = function (node, cb) {
if (Array.isArray(node)) {
node.forEach(function (x) {
if(x != null) {
x.parent = node;
traverse(x, cb);
}
});
}
else if (node && typeof node === 'object') {
cb(node);
Object.keys(node).forEach(function (key) {
if (key === 'parent' || !node[key]) return;
node[key].parent = node;
traverse(node[key], cb);
});
}
};
var walk = function (src, opts, cb) {
var ast = esprima.parse(src, opts);
traverse(ast, cb);
};
var exports = module.exports = function (src, opts) {
return exports.find(src, opts).strings;
};
exports.find = function (src, opts) {
if (!opts) opts = {};
opts.parse = opts.parse || {};
opts.parse.tolerant = true;
var word = opts.word === undefined ? 'require' : opts.word;
if (typeof src !== 'string') src = String(src);
src = src.replace(/^#![^\n]*\n/, '');
var isRequire = opts.isRequire || function (node) {
var c = node.callee;
return c
&& node.type === 'CallExpression'
&& c.type === 'Identifier'
&& c.name === word
;
}
var modules = { strings : [], expressions : [] };
if (opts.nodes) modules.nodes = [];
if (src.indexOf(word) == -1) return modules;
walk(src, opts.parse, function (node) {
if (!isRequire(node)) return;
if (node.arguments.length
&& node.arguments[0].type === 'Literal') {
modules.strings.push(node.arguments[0].value);
}
else {
modules.expressions.push(escodegen.generate(node.arguments[0]));
}
if (opts.nodes) modules.nodes.push(node);
});
return modules;
};
},{"escodegen":7,"esprima":19}],7:[function(require,module,exports){
(function (process){
/*
Copyright (C) 2012 Michael Ficarra <escodegen.copyright@michael.ficarra.me>
Copyright (C) 2012 Robert Gust-Bardon <donate@robert.gust-bardon.org>
Copyright (C) 2012 John Freeman <jfreeman08@gmail.com>
Copyright (C) 2011-2012 Ariya Hidayat <ariya.hidayat@gmail.com>
Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*jslint bitwise:true */
/*global escodegen:true, exports:true, generateStatement:true, generateExpression:true, generateFunctionBody:true, process:true, require:true, define:true*/
(function (factory, global) {
'use strict';
// Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
// and plain browser loading,
if (typeof define === 'function' && define.amd) {
define(['exports'], function (exports) {
factory(exports, global);
});
} else if (typeof exports !== 'undefined') {
factory(exports, global);
} else {
factory((global.escodegen = {}), global);
}
}(function (exports, global) {
'use strict';
var Syntax,
Precedence,
BinaryPrecedence,
Regex,
VisitorKeys,
VisitorOption,
SourceNode,
isArray,
base,
indent,
json,
renumber,
hexadecimal,
quotes,
escapeless,
newline,
space,
parentheses,
semicolons,
safeConcatenation,
directive,
extra,
parse,
sourceMap;
Syntax = {
AssignmentExpression: 'AssignmentExpression',
ArrayExpression: 'ArrayExpression',
ArrayPattern: 'ArrayPattern',
BlockStatement: 'BlockStatement',
BinaryExpression: 'BinaryExpression',
BreakStatement: 'BreakStatement',
CallExpression: 'CallExpression',
CatchClause: 'CatchClause',
ComprehensionBlock: 'ComprehensionBlock',
ComprehensionExpression: 'ComprehensionExpression',
ConditionalExpression: 'ConditionalExpression',
ContinueStatement: 'ContinueStatement',
DirectiveStatement: 'DirectiveStatement',
DoWhileStatement: 'DoWhileStatement',
DebuggerStatement: 'DebuggerStatement',
EmptyStatement: 'EmptyStatement',
ExpressionStatement: 'ExpressionStatement',
ForStatement: 'ForStatement',
ForInStatement: 'ForInStatement',
FunctionDeclaration: 'FunctionDeclaration',
FunctionExpression: 'FunctionExpression',
Identifier: 'Identifier',
IfStatement: 'IfStatement',
Literal: 'Literal',
LabeledStatement: 'LabeledStatement',
LogicalExpression: 'LogicalExpression',
MemberExpression: 'MemberExpression',
NewExpression: 'NewExpression',
ObjectExpression: 'ObjectExpression',
ObjectPattern: 'ObjectPattern',
Program: 'Program',
Property: 'Property',
ReturnStatement: 'ReturnStatement',
SequenceExpression: 'SequenceExpression',
SwitchStatement: 'SwitchStatement',
SwitchCase: 'SwitchCase',
ThisExpression: 'ThisExpression',
ThrowStatement: 'ThrowStatement',
TryStatement: 'TryStatement',
UnaryExpression: 'UnaryExpression',
UpdateExpression: 'UpdateExpression',
VariableDeclaration: 'VariableDeclaration',
VariableDeclarator: 'VariableDeclarator',
WhileStatement: 'WhileStatement',
WithStatement: 'WithStatement',
YieldExpression: 'YieldExpression',
};
Precedence = {
Sequence: 0,
Assignment: 1,
Conditional: 2,
LogicalOR: 3,
LogicalAND: 4,
BitwiseOR: 5,
BitwiseXOR: 6,
BitwiseAND: 7,
Equality: 8,
Relational: 9,
BitwiseSHIFT: 10,
Additive: 11,
Multiplicative: 12,
Unary: 13,
Postfix: 14,
Call: 15,
New: 16,
Member: 17,
Primary: 18
};
BinaryPrecedence = {
'||': Precedence.LogicalOR,
'&&': Precedence.LogicalAND,
'|': Precedence.BitwiseOR,
'^': Precedence.BitwiseXOR,
'&': Precedence.BitwiseAND,
'==': Precedence.Equality,
'!=': Precedence.Equality,
'===': Precedence.Equality,
'!==': Precedence.Equality,
'is': Precedence.Equality,
'isnt': Precedence.Equality,
'<': Precedence.Relational,
'>': Precedence.Relational,
'<=': Precedence.Relational,
'>=': Precedence.Relational,
'in': Precedence.Relational,
'instanceof': Precedence.Relational,
'<<': Precedence.BitwiseSHIFT,
'>>': Precedence.BitwiseSHIFT,
'>>>': Precedence.BitwiseSHIFT,
'+': Precedence.Additive,
'-': Precedence.Additive,
'*': Precedence.Multiplicative,
'%': Precedence.Multiplicative,
'/': Precedence.Multiplicative
};
Regex = {
NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]')
};
function getDefaultOptions() {
// default options
return {
indent: null,
base: null,
parse: null,
comment: false,
format: {
indent: {
style: ' ',
base: 0,
adjustMultilineComment: false
},
json: false,
renumber: false,
hexadecimal: false,
quotes: 'single',
escapeless: false,
compact: false,
parentheses: true,
semicolons: true,
safeConcatenation: false
},
moz: {
starlessGenerator: false,
parenthesizedComprehensionBlock: false
},
sourceMap: null,
sourceMapWithCode: false,
directive: false,
verbatim: null
};
}
function stringToArray(str) {
var length = str.length,
result = [],
i;
for (i = 0; i < length; i += 1) {
result[i] = str.charAt(i);
}
return result;
}
function stringRepeat(str, num) {
var result = '';
for (num |= 0; num > 0; num >>>= 1, str += str) {
if (num & 1) {
result += str;
}
}
return result;
}
isArray = Array.isArray;
if (!isArray) {
isArray = function isArray(array) {
return Object.prototype.toString.call(array) === '[object Array]';
};
}
// Fallback for the non SourceMap environment
function SourceNodeMock(line, column, filename, chunk) {
var result = [];
function flatten(input) {
var i, iz;
if (isArray(input)) {
for (i = 0, iz = input.length; i < iz; ++i) {
flatten(input[i]);
}
} else if (input instanceof SourceNodeMock) {
result.push(input);
} else if (typeof input === 'string' && input) {
result.push(input);
}
}
flatten(chunk);
this.children = result;
}
SourceNodeMock.prototype.toString = function toString() {
var res = '', i, iz, node;
for (i = 0, iz = this.children.length; i < iz; ++i) {
node = this.children[i];
if (node instanceof SourceNodeMock) {
res += node.toString();
} else {
res += node;
}
}
return res;
};
SourceNodeMock.prototype.replaceRight = function replaceRight(pattern, replacement) {
var last = this.children[this.children.length - 1];
if (last instanceof SourceNodeMock) {
last.replaceRight(pattern, replacement);
} else if (typeof last === 'string') {
this.children[this.children.length - 1] = last.replace(pattern, replacement);
} else {
this.children.push(''.replace(pattern, replacement));
}
return this;
};
SourceNodeMock.prototype.join = function join(sep) {
var i, iz, result;
result = [];
iz = this.children.length;
if (iz > 0) {
for (i = 0, iz -= 1; i < iz; ++i) {
result.push(this.children[i], sep);
}
result.push(this.children[iz]);
this.children = result;
}
return this;
};
function hasLineTerminator(str) {
return /[\r\n]/g.test(str);
}
function endsWithLineTerminator(str) {
var ch = str.charAt(str.length - 1);
return ch === '\r' || ch === '\n';
}
function shallowCopy(obj) {
var ret = {}, key;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
ret[key] = obj[key];
}
}
return ret;
}
function deepCopy(obj) {
var ret = {}, key, val;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
val = obj[key];
if (typeof val === 'object' && val !== null) {
ret[key] = deepCopy(val);
} else {
ret[key] = val;
}
}
}
return ret;
}
function updateDeeply(target, override) {
var key, val;
function isHashObject(target) {
return typeof target === 'object' && target instanceof Object && !(target instanceof RegExp);
}
for (key in override) {
if (override.hasOwnProperty(key)) {
val = override[key];
if (isHashObject(val)) {
if (isHashObject(target[key])) {
updateDeeply(target[key], val);
} else {
target[key] = updateDeeply({}, val);
}
} else {
target[key] = val;
}
}
}
return target;
}
function generateNumber(value) {
var result, point, temp, exponent, pos;
if (value !== value) {
throw new Error('Numeric literal whose value is NaN');
}
if (value < 0 || (value === 0 && 1 / value < 0)) {
throw new Error('Numeric literal whose value is negative');
}
if (value === 1 / 0) {
return json ? 'null' : renumber ? '1e400' : '1e+400';
}
result = '' + value;
if (!renumber || result.length < 3) {
return result;
}
point = result.indexOf('.');
if (!json && result.charAt(0) === '0' && point === 1) {
point = 0;
result = result.slice(1);
}
temp = result;
result = result.replace('e+', 'e');
exponent = 0;
if ((pos = temp.indexOf('e')) > 0) {
exponent = +temp.slice(pos + 1);
temp = temp.slice(0, pos);
}
if (point >= 0) {
exponent -= temp.length - point - 1;
temp = +(temp.slice(0, point) + temp.slice(point + 1)) + '';
}
pos = 0;
while (temp.charAt(temp.length + pos - 1) === '0') {
pos -= 1;
}
if (pos !== 0) {
exponent -= pos;
temp = temp.slice(0, pos);
}
if (exponent !== 0) {
temp += 'e' + exponent;
}
if ((temp.length < result.length ||
(hexadecimal && value > 1e12 && Math.floor(value) === value && (temp = '0x' + value.toString(16)).length < result.length)) &&
+temp === value) {
result = temp;
}
return result;
}
function escapeAllowedCharacter(ch, next) {
var code = ch.charCodeAt(0), hex = code.toString(16), result = '\\';
switch (ch) {
case '\b':
result += 'b';
break;
case '\f':
result += 'f';
break;
case '\t':
result += 't';
break;
default:
if (json || code > 0xff) {
result += 'u' + '0000'.slice(hex.length) + hex;
} else if (ch === '\u0000' && '0123456789'.indexOf(next) < 0) {
result += '0';
} else if (ch === '\v') {
result += 'v';
} else {
result += 'x' + '00'.slice(hex.length) + hex;
}
break;
}
return result;
}
function escapeDisallowedCharacter(ch) {
var result = '\\';
switch (ch) {
case '\\':
result += '\\';
break;
case '\n':
result += 'n';
break;
case '\r':
result += 'r';
break;
case '\u2028':
result += 'u2028';
break;
case '\u2029':
result += 'u2029';
break;
default:
throw new Error('Incorrectly classified character');
}
return result;
}
function escapeDirective(str) {
var i, iz, ch, single, buf, quote;
buf = str;
if (typeof buf[0] === 'undefined') {
buf = stringToArray(buf);
}
quote = quotes === 'double' ? '"' : '\'';
for (i = 0, iz = buf.length; i < iz; i += 1) {
ch = buf[i];
if (ch === '\'') {
quote = '"';
break;
} else if (ch === '"') {
quote = '\'';
break;
} else if (ch === '\\') {
i += 1;
}
}
return quote + str + quote;
}
function escapeString(str) {
var result = '', i, len, ch, next, singleQuotes = 0, doubleQuotes = 0, single;
if (typeof str[0] === 'undefined') {
str = stringToArray(str);
}
for (i = 0, len = str.length; i < len; i += 1) {
ch = str[i];
if (ch === '\'') {
singleQuotes += 1;
} else if (ch === '"') {
doubleQuotes += 1;
} else if (ch === '/' && json) {
result += '\\';
} else if ('\\\n\r\u2028\u2029'.indexOf(ch) >= 0) {
result += escapeDisallowedCharacter(ch);
continue;
} else if ((json && ch < ' ') || !(json || escapeless || (ch >= ' ' && ch <= '~'))) {
result += escapeAllowedCharacter(ch, str[i + 1]);
continue;
}
result += ch;
}
single = !(quotes === 'double' || (quotes === 'auto' && doubleQuotes < singleQuotes));
str = result;
result = single ? '\'' : '"';
if (typeof str[0] === 'undefined') {
str = stringToArray(str);
}
for (i = 0, len = str.length; i < len; i += 1) {
ch = str[i];
if ((ch === '\'' && single) || (ch === '"' && !single)) {
result += '\\';
}
result += ch;
}
return result + (single ? '\'' : '"');
}
function isWhiteSpace(ch) {
return '\t\v\f \xa0'.indexOf(ch) >= 0 || (ch.charCodeAt(0) >= 0x1680 && '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\ufeff'.indexOf(ch) >= 0);
}
function isLineTerminator(ch) {
return '\n\r\u2028\u2029'.indexOf(ch) >= 0;
}
function isIdentifierPart(ch) {
return (ch === '$') || (ch === '_') || (ch === '\\') ||
(ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
((ch >= '0') && (ch <= '9')) ||
((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));
}
function toSourceNode(generated, node) {
if (node == null) {
if (generated instanceof SourceNode) {
return generated;
} else {
node = {};
}
}
if (node.loc == null) {
return new SourceNode(null, null, sourceMap, generated);
}
return new SourceNode(node.loc.start.line, node.loc.start.column, (sourceMap === true ? node.loc.source || null : sourceMap), generated);
}
function join(left, right) {
var leftSource = toSourceNode(left).toString(),
rightSource = toSourceNode(right).toString(),
leftChar = leftSource.charAt(leftSource.length - 1),
rightChar = rightSource.charAt(0);
if (((leftChar === '+' || leftChar === '-') && leftChar === rightChar) || (isIdentifierPart(leftChar) && isIdentifierPart(rightChar))) {
return [left, ' ', right];
} else if (isWhiteSpace(leftChar) || isLineTerminator(leftChar) || isWhiteSpace(rightChar) || isLineTerminator(rightChar)) {
return [left, right];
}
return [left, space, right];
}
function addIndent(stmt) {
return [base, stmt];
}
function withIndent(fn) {
var previousBase, result;
previousBase = base;
base += indent;
result = fn.call(this, base);
base = previousBase;
return result;
}
function calculateSpaces(str) {
var i;
for (i = str.length - 1; i >= 0; i -= 1) {
if (isLineTerminator(str.charAt(i))) {
break;
}
}
return (str.length - 1) - i;
}
function adjustMultilineComment(value, specialBase) {
var array, i, len, line, j, ch, spaces, previousBase;
array = value.split(/\r\n|[\r\n]/);
spaces = Number.MAX_VALUE;
// first line doesn't have indentation
for (i = 1, len = array.length; i < len; i += 1) {
line = array[i];
j = 0;
while (j < line.length && isWhiteSpace(line[j])) {
j += 1;
}
if (spaces > j) {
spaces = j;
}
}
if (typeof specialBase !== 'undefined') {
// pattern like
// {
// var t = 20; /*
// * this is comment
// */
// }
previousBase = base;
if (array[1][spaces] === '*') {
specialBase += ' ';
}
base = specialBase;
} else {
if (spaces & 1) {
// /*
// *
// */
// If spaces are odd number, above pattern is considered.
// We waste 1 space.
spaces -= 1;
}
previousBase = base;
}
for (i = 1, len = array.length; i < len; i += 1) {
array[i] = toSourceNode(addIndent(array[i].slice(spaces))).join('');
}
base = previousBase;
return array.join('\n');
}
function generateComment(comment, specialBase) {
if (comment.type === 'Line') {
if (endsWithLineTerminator(comment.value)) {
return '//' + comment.value;
} else {
// Always use LineTerminator
return '//' + comment.value + '\n';
}
}
if (extra.format.indent.adjustMultilineComment && /[\n\r]/.test(comment.value)) {
return adjustMultilineComment('/*' + comment.value + '*/', specialBase);
}
return '/*' + comment.value + '*/';
}
function addCommentsToStatement(stmt, result) {
var i, len, comment, save, node, tailingToStatement, specialBase, fragment;
if (stmt.leadingComments && stmt.leadingComments.length > 0) {
save = result;
comment = stmt.leadingComments[0];
result = [];
if (safeConcatenation && stmt.type === Syntax.Program && stmt.body.length === 0) {
result.push('\n');
}
result.push(generateComment(comment));
if (!endsWithLineTerminator(toSourceNode(result).toString())) {
result.push('\n');
}
for (i = 1, len = stmt.leadingComments.length; i < len; i += 1) {
comment = stmt.leadingComments[i];
fragment = [generateComment(comment)];
if (!endsWithLineTerminator(toSourceNode(fragment).toString())) {
fragment.push('\n');
}
result.push(addIndent(fragment));
}
result.push(addIndent(save));
}
if (stmt.trailingComments) {
tailingToStatement = !endsWithLineTerminator(toSourceNode(result).toString());
specialBase = stringRepeat(' ', calculateSpaces(toSourceNode([base, result, indent]).toString()));
for (i = 0, len = stmt.trailingComments.length; i < len; i += 1) {
comment = stmt.trailingComments[i];
if (tailingToStatement) {
// We assume target like following script
//
// var t = 20; /**
// * This is comment of t
// */
if (i === 0) {
// first case
result = [result, indent];
} else {
result = [result, specialBase];
}
result.push(generateComment(comment, specialBase));
} else {
result = [result, addIndent(generateComment(comment))];
}
if (i !== len - 1 && !endsWithLineTerminator(toSourceNode(result).toString())) {
result = [result, '\n'];
}
}
}
return result;
}
function parenthesize(text, current, should) {
if (current < should) {
return ['(', text, ')'];
}
return text;
}
function maybeBlock(stmt, semicolonOptional, functionBody) {
var result, noLeadingComment;
noLeadingComment = !extra.comment || !stmt.leadingComments;
if (stmt.type === Syntax.BlockStatement && noLeadingComment) {
return [space, generateStatement(stmt, { functionBody: functionBody })];
}
if (stmt.type === Syntax.EmptyStatement && noLeadingComment) {
return ';';
}
withIndent(function () {
result = [newline, addIndent(generateStatement(stmt, { semicolonOptional: semicolonOptional, functionBody: functionBody }))];
});
return result;
}
function maybeBlockSuffix(stmt, result) {
var ends = endsWithLineTerminator(toSourceNode(result).toString());
if (stmt.type === Syntax.BlockStatement && (!extra.comment || !stmt.leadingComments) && !ends) {
return [result, space];
}
if (ends) {
return [result, base];
}
return [result, newline, base];
}
function generateVerbatim(expr, option) {
var i, result;
result = expr[extra.verbatim].split(/\r\n|\n/);
for (i = 1; i < result.length; i++) {
result[i] = newline + base + result[i];
}
result = parenthesize(result, Precedence.Sequence, option.precedence);
return toSourceNode(result, expr);
}
function generateFunctionBody(node) {
var result, i, len, expr;
result = ['('];
for (i = 0, len = node.params.length; i < len; i += 1) {
result.push(node.params[i].name);
if (i + 1 < len) {
result.push(',' + space);
}
}
result.push(')');
if (node.expression) {
result.push(space);
expr = generateExpression(node.body, {
precedence: Precedence.Assignment,
allowIn: true,
allowCall: true
});
if (expr.toString().charAt(0) === '{') {
expr = ['(', expr, ')'];
}
result.push(expr);
} else {
result.push(maybeBlock(node.body, false, true));
}
return result;
}
function generateExpression(expr, option) {
var result, precedence, currentPrecedence, i, len, raw, fragment, multiline, leftChar, leftSource, rightChar, rightSource, allowIn, allowCall, allowUnparenthesizedNew, property, key, value;
precedence = option.precedence;
allowIn = option.allowIn;
allowCall = option.allowCall;
if (extra.verbatim && expr.hasOwnProperty(extra.verbatim)) {
return generateVerbatim(expr, option);
}
switch (expr.type) {
case Syntax.SequenceExpression:
result = [];
allowIn |= (Precedence.Sequence < precedence);
for (i = 0, len = expr.expressions.length; i < len; i += 1) {
result.push(generateExpression(expr.expressions[i], {
precedence: Precedence.Assignment,
allowIn: allowIn,
allowCall: true
}));
if (i + 1 < len) {
result.push(',' + space);
}
}
result = parenthesize(result, Precedence.Sequence, precedence);
break;
case Syntax.AssignmentExpression:
allowIn |= (Precedence.Assignment < precedence);
result = parenthesize(
[
generateExpression(expr.left, {
precedence: Precedence.Call,
allowIn: allowIn,
allowCall: true
}),
space + expr.operator + space,
generateExpression(expr.right, {
precedence: Prec