diff --git a/package.json b/package.json index 003e7dc..8f6f384 100644 --- a/package.json +++ b/package.json @@ -7,7 +7,8 @@ "author": "", "license": "", "dependencies": { - "@vant/weapp": "^1.11.6" + "@vant/weapp": "^1.11.6", + "miniprogram-licia": "^1.39.2" }, "devDependencies": { "miniprogram-api-typings": "^2.8.3-1" diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 56e8dcf..1dd6054 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -11,6 +11,9 @@ importers: '@vant/weapp': specifier: ^1.11.6 version: 1.11.6 + miniprogram-licia: + specifier: ^1.39.2 + version: 1.43.0 devDependencies: miniprogram-api-typings: specifier: ^2.8.3-1 @@ -24,8 +27,13 @@ packages: miniprogram-api-typings@2.12.0: resolution: {integrity: sha512-ibvbqeslVFur0IAvTxLMvsbtvVcMo6gwvOnj0YZHV7aeDLu091VQRrETT2QuiG9P6aZWRcxeNGJChRKVPCp9VQ==} + miniprogram-licia@1.43.0: + resolution: {integrity: sha512-NTQxO0LaoIv66I7civEqyUwtF36My7S0TwGyvMAFUpUqGXcQZsM9Ng2OWwHaBvlqdjjPHSacTMH3XqGpnieEow==} + snapshots: '@vant/weapp@1.11.6': {} miniprogram-api-typings@2.12.0: {} + + miniprogram-licia@1.43.0: {} diff --git a/src/app.ts b/src/app.ts index bee4c87..4090ce0 100644 --- a/src/app.ts +++ b/src/app.ts @@ -1,7 +1,24 @@ // app.ts +const licia = require("miniprogram-licia"); +import { request } from "./utils/request"; + App({ - globalData: {}, + globalData: { + // 测试号 wx2b0bb13edf717c1d + // dev + // appid:wxaae50c206446a964 + url: "https://m.takeda.hbraas.com", + upFileUrl: "https://m.takeda.hbraas.com/", + imageUrl: "https://m.takeda.hbraas.com/zd/", + // pro + // appid:wx96f45ca4f1fa36ec + // url: 'https://m.takeda.hbraas.com', + // upFileUrl: 'https://m.takeda.hbraas.com/', + // imageUrl: 'https://m.takeda.hbraas.com/zd/', + }, onLaunch() { + wx.ajax = licia.curry(request)({ gUrl: this.globalData.url }); + wx.login({ success: (res) => { console.log("code", res); diff --git a/src/miniprogram_npm/miniprogram-licia/Benchmark.js b/src/miniprogram_npm/miniprogram-licia/Benchmark.js new file mode 100644 index 0000000..5e3e5ee --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Benchmark.js @@ -0,0 +1,244 @@ +var Class = require('./Class'); +var defaults = require('./defaults'); +var Promise = require('./Promise'); +var perfNow = require('./perfNow'); +var delay = require('./delay'); +var average = require('./average'); +var reduce = require('./reduce'); +var each = require('./each'); +var map = require('./map'); +var table = require('./table'); +var toStr = require('./toStr'); +exports = Class( + { + initialize: function Benchmark(fn) { + var options = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : {}; + defaults(options, defOpts); + this._fn = fn; + this._isRunning = false; + this._options = options; + }, + run: function() { + var _this = this; + if (this._isRunning) { + return this._pendingPromise; + } + this._reset(); + this._isRunning = true; + var options = this._options; + var pendingPromise = new Promise(function(resolve, reject) { + var runSample = function() { + var initCount = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : 1; + delay(function() { + _this + ._runSample(initCount) + .then(function(_ref) { + var period = _ref.period, + count = _ref.count; + var sample = _this._sample; + sample.push(period); + if ( + perfNow() - _this._timeStamp < + options.maxTime || + sample.length < options.minSamples + ) { + runSample(count); + } else { + resolve(_this._calcResult()); + } + }) + .catch(function(err) { + reject(err); + }); + }, options.delay); + }; + runSample(); + }); + function complete() { + this._isRunning = false; + delete this._pendingPromise; + } + pendingPromise.then(complete).catch(complete); + this._pendingPromise = pendingPromise; + return pendingPromise; + }, + _reset: function() { + this._timeStamp = perfNow(); + this._sample = []; + }, + _calcResult: function() { + var sample = this._sample; + var result = { + sample: sample, + toString: function() { + var hz = this.hz, + rme = this.rme, + name = this.name; + var size = this.sample.length; + return '' + .concat(name, ' x ') + .concat( + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)), + ' ops/sec \xB1' + ) + .concat(rme.toFixed(2), '% (') + .concat(size, ' run') + .concat(size === 1 ? '' : 's', ' sampled)'); + } + }; + var size = sample.length; + result.name = this._options.name || this._fn.name || 'anonymous'; + result.mean = average.apply(null, sample); + function varOf(sum, x) { + return sum + Math.pow(x - result.mean, 2); + } + result.variance = reduce(sample, varOf, 0) / (size - 1) || 0; + result.deviation = Math.sqrt(result.variance); + result.sem = result.deviation / Math.sqrt(size); + var critical = tTable[Math.round(size - 1) || 1] || tTable.infinity; + result.moe = result.sem * critical; + result.rme = (result.moe / result.mean) * 100 || 0; + result.hz = 1000 / result.mean; + return result; + }, + _runSample: function(count) { + var _this2 = this; + var options = this._options; + var minTime = options.minTime; + return new Promise(function(resolve, reject) { + var runCycle = function(count) { + delay(function() { + var elapsed = 0; + try { + elapsed = _this2._runCycle(count); + } catch (e) { + return reject(e); + } + var period = elapsed / count; + if (elapsed < minTime) { + if (elapsed === 0) { + count *= 100; + } else { + count += Math.ceil( + (minTime - elapsed) / period + ); + } + runCycle(count); + } else { + resolve({ + count: count, + period: period + }); + } + }, options.delay); + }; + runCycle(count); + }); + }, + _runCycle: function(count) { + var fn = this._fn; + var now = perfNow(); + while (count--) { + fn(); + } + return perfNow() - now; + } + }, + { + all: function(benches, options) { + var promises = []; + each(benches, function(bench) { + if (!(bench instanceof exports)) { + bench = new exports(bench, options); + } + promises.push(bench.run()); + }); + return Promise.all(promises).then(function(results) { + results.toString = function() { + var data = map(results, function(_ref2, idx) { + var name = _ref2.name, + sample = _ref2.sample, + hz = _ref2.hz, + rme = _ref2.rme; + var columns = []; + var size = sample.length; + columns.push( + toStr(idx + 1), + name || 'anonymous', + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)), + '\xB1'.concat(rme.toFixed(2), '%'), + '' + .concat(size, ' run') + .concat(size === 1 ? '' : 's') + ); + return columns; + }); + data.unshift([ + 'index', + 'name', + 'ops/sec', + 'rme', + 'sampled' + ]); + return table(data); + }; + return results; + }); + } + } +); +var defOpts = { + minTime: 50, + maxTime: 5000, + minSamples: 5, + delay: 5, + name: '' +}; +var tTable = { + '1': 12.706, + '2': 4.303, + '3': 3.182, + '4': 2.776, + '5': 2.571, + '6': 2.447, + '7': 2.365, + '8': 2.306, + '9': 2.262, + '10': 2.228, + '11': 2.201, + '12': 2.179, + '13': 2.16, + '14': 2.145, + '15': 2.131, + '16': 2.12, + '17': 2.11, + '18': 2.101, + '19': 2.093, + '20': 2.086, + '21': 2.08, + '22': 2.074, + '23': 2.069, + '24': 2.064, + '25': 2.06, + '26': 2.056, + '27': 2.052, + '28': 2.048, + '29': 2.045, + '30': 2.042, + infinity: 1.96 +}; +function formatNumber(number) { + number = String(number).split('.'); + return ( + number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') + + (number[1] ? '.' + number[1] : '') + ); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/BloomFilter.js b/src/miniprogram_npm/miniprogram-licia/BloomFilter.js new file mode 100644 index 0000000..c65c8d6 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/BloomFilter.js @@ -0,0 +1,46 @@ +var Class = require('./Class'); +var fill = require('./fill'); +var fnv1a = require('./fnv1a'); +var strHash = require('./strHash'); +var each = require('./each'); +var some = require('./some'); +exports = Class({ + initialize: function() { + var size = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : 1024; + var k = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : 3; + this._buckets = fill(new Array(size), 0); + this._k = k; + this._size = size; + }, + add: function(val) { + var _this = this; + each(this._locations(val), function(location) { + return (_this._buckets[location] = 1); + }); + }, + test: function(val) { + var _this2 = this; + return !some(this._locations(val), function(location) { + return _this2._buckets[location] === 0; + }); + }, + _locations: function(val) { + var ret = []; + var size = this._size; + var a = fnv1a(val); + var b = strHash(val); + + for (var i = 0; i < this._k; i++) { + ret[i] = (a + b * i) % size; + } + return ret; + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Caseless.js b/src/miniprogram_npm/miniprogram-licia/Caseless.js new file mode 100644 index 0000000..d2ae6f8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Caseless.js @@ -0,0 +1,35 @@ +var Class = require('./Class'); +var lowerCase = require('./lowerCase'); +var keys = require('./keys'); +exports = Class({ + initialize: function(obj) { + this._target = obj; + }, + set: function(key, val) { + var name = this.getKey(key); + if (name) key = name; + this._target[key] = val; + }, + get: function(key) { + key = this.getKey(key); + if (key) { + return this._target[key]; + } + }, + getKey: function(key) { + var name = lowerCase(key); + var _keys = keys(this._target); + for (var i = 0, len = _keys.length; i < len; i++) { + var _key = _keys[i]; + if (lowerCase(_key) === name) return _key; + } + }, + remove: function(key) { + delete this._target[this.getKey(key)]; + }, + has: function(key) { + return !!this.getKey(key); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Channel.js b/src/miniprogram_npm/miniprogram-licia/Channel.js new file mode 100644 index 0000000..97de876 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Channel.js @@ -0,0 +1,48 @@ +var Emitter = require('./Emitter'); +var each = require('./each'); +var remove = require('./remove'); +var some = require('./some'); +exports = Emitter.extend({ + initialize: function Channel() { + this._connections = []; + this.callSuper(Emitter, 'initialize'); + }, + send: function(msg) { + var _this = this; + each(this._connections, function(connection) { + connection.emit('message', msg, _this); + }); + }, + connect: function(connection) { + if (this.isConnected(connection)) { + return; + } + this._connections.push(connection); + connection.connect(this); + }, + disconnect: function(connection) { + if (!this.isConnected(connection)) { + return; + } + remove(this._connections, function(item) { + return item === connection; + }); + connection.disconnect(this); + }, + isConnected: function(connection) { + if (connection === this) { + throw new Error('Channel cannot be connected to itself.'); + } + return some(this._connections, function(item) { + return item === connection; + }); + }, + destroy: function() { + var _this2 = this; + each(this._connections, function(connection) { + _this2.disconnect(connection); + }); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Class.js b/src/miniprogram_npm/miniprogram-licia/Class.js new file mode 100644 index 0000000..519ee3f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Class.js @@ -0,0 +1,64 @@ +var extend = require('./extend'); +var toArr = require('./toArr'); +var inherits = require('./inherits'); +var safeGet = require('./safeGet'); +var isMiniProgram = require('./isMiniProgram'); +exports = function(methods, statics) { + return Base.extend(methods, statics); +}; +function makeClass(parent, methods, statics) { + statics = statics || {}; + var className = + methods.className || safeGet(methods, 'initialize.name') || ''; + delete methods.className; + var ctor = function() { + var args = toArr(arguments); + return this.initialize + ? this.initialize.apply(this, args) || this + : this; + }; + if (!isMiniProgram) { + try { + ctor = new Function( + 'toArr', + 'return function ' + + className + + '()' + + '{' + + 'var args = toArr(arguments);' + + 'return this.initialize ? this.initialize.apply(this, args) || this : this;' + + '};' + )(toArr); + } catch (e) {} + } + inherits(ctor, parent); + ctor.prototype.constructor = ctor; + ctor.extend = function(methods, statics) { + return makeClass(ctor, methods, statics); + }; + ctor.inherits = function(Class) { + inherits(ctor, Class); + }; + ctor.methods = function(methods) { + extend(ctor.prototype, methods); + return ctor; + }; + ctor.statics = function(statics) { + extend(ctor, statics); + return ctor; + }; + ctor.methods(methods).statics(statics); + return ctor; +} +var Base = (exports.Base = makeClass(Object, { + className: 'Base', + callSuper: function(parent, name, args) { + var superMethod = parent.prototype[name]; + return superMethod.apply(this, args); + }, + toString: function() { + return this.constructor.name; + } +})); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Color.js b/src/miniprogram_npm/miniprogram-licia/Color.js new file mode 100644 index 0000000..acf0965 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Color.js @@ -0,0 +1,95 @@ +var Class = require('./Class'); +var isStr = require('./isStr'); +var clamp = require('./clamp'); +var rgbToHsl = require('./rgbToHsl'); +var hslToRgb = require('./hslToRgb'); +var hex = require('./hex'); +exports = Class( + { + initialize: function Color(color) { + if (isStr(color)) color = exports.parse(color); + this.model = color.model; + this.val = color.val; + }, + toRgb: function() { + var val = this.val; + if (this.model === 'hsl') val = hslToRgb(val); + var prefix = 'rgba'; + if (val[3] === 1) { + prefix = 'rgb'; + val = val.slice(0, 3); + } + return prefix + '(' + val.join(', ') + ')'; + }, + toHex: function() { + var val = this.val; + if (this.model === 'hsl') val = hslToRgb(val); + var ret = hex.encode(val.slice(0, 3)); + if (ret[0] === ret[1] && ret[2] === ret[3] && ret[4] === ret[5]) { + ret = ret[0] + ret[2] + ret[5]; + } + return '#' + ret; + }, + toHsl: function() { + var val = this.val; + if (this.model === 'rgb') val = rgbToHsl(val); + var prefix = 'hsla'; + if (val[3] === 1) { + prefix = 'hsl'; + val = val.slice(0, 3); + } + val[1] = val[1] + '%'; + val[2] = val[2] + '%'; + return prefix + '(' + val.join(', ') + ')'; + } + }, + { + parse: function(colorStr) { + var i, match; + var val = [0, 0, 0, 1], + model = 'rgb'; + + if ((match = colorStr.match(regHexAbbr))) { + match = match[1]; + for (i = 0; i < 3; i++) { + val[i] = parseInt(match[i] + match[i], 16); + } + } else if ((match = colorStr.match(regHex))) { + match = match[1]; + for (i = 0; i < 3; i++) { + var i2 = i * 2; + val[i] = parseInt(match.slice(i2, i2 + 2), 16); + } + } else if ((match = colorStr.match(regRgba))) { + for (i = 0; i < 3; i++) { + val[i] = parseInt(match[i + 1], 0); + } + if (match[4]) val[3] = parseFloat(match[4]); + } else if ((match = colorStr.match(regRgbaPer))) { + for (i = 0; i < 3; i++) { + val[i] = Math.round(parseFloat(match[i + 1]) * 2.55); + } + if (match[4]) val[3] = parseFloat(match[4]); + } else if ((match = colorStr.match(regHsla))) { + model = 'hsl'; + val = [ + ((parseFloat(match[1]) % 360) + 360) % 360, + clamp(parseFloat(match[2]), 0, 100), + clamp(parseFloat(match[3]), 0, 100), + clamp(parseFloat(match[4]), 0, 1) + ]; + } + return { + val: val, + model: model + }; + } + } +); +var regHexAbbr = /^#([a-fA-F0-9]{3})$/; +var regHex = /^#([a-fA-F0-9]{6})$/; +var regRgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/; +var regRgbaPer = /^rgba?\(\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/; +var regHsla = /^hsla?\(\s*([+-]?\d*[.]?\d+)(?:deg)?\s*,\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Delegator.js b/src/miniprogram_npm/miniprogram-licia/Delegator.js new file mode 100644 index 0000000..c968eb8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Delegator.js @@ -0,0 +1,48 @@ +var Class = require('./Class'); +var safeGet = require('./safeGet'); +var defineProp = require('./defineProp'); +var isStr = require('./isStr'); +exports = Class({ + initialize: function Delegator(host, target) { + this._host = host; + if (isStr(target)) { + target = safeGet(host, target); + } + this._target = target; + }, + method: function(name, targetName) { + var target = this._target; + var fn = target[targetName || name]; + this._host[name] = function() { + return fn.apply(target, arguments); + }; + return this; + }, + getter: function(name, targetName) { + var target = this._target; + targetName = targetName || name; + defineProp(this._host, name, { + get: function() { + return target[targetName]; + }, + configurable: true + }); + return this; + }, + setter: function(name, targetName) { + var target = this._target; + targetName = targetName || name; + defineProp(this._host, name, { + set: function(val) { + return (target[targetName] = val); + }, + configurable: true + }); + return this; + }, + access: function(name, targetName) { + return this.getter(name, targetName).setter(name, targetName); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Dispatcher.js b/src/miniprogram_npm/miniprogram-licia/Dispatcher.js new file mode 100644 index 0000000..427ad82 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Dispatcher.js @@ -0,0 +1,55 @@ +var Class = require('./Class'); +var uniqId = require('./uniqId'); +exports = Class({ + initialize: function Dispatcher() { + this._callbacks = {}; + this._isDispatching = false; + this._isHandled = {}; + this._isPending = {}; + }, + dispatch: function(payload) { + this._startDispatching(payload); + for (var id in this._callbacks) { + if (this._isPending[id]) continue; + this._invokeCb(id); + } + this._stopDispatching(); + }, + register: function(cb) { + var id = uniqId('ID_'); + this._callbacks[id] = cb; + return id; + }, + waitFor: function(ids) { + for (var i = 0, len = ids.length; i < len; i++) { + var id = ids[i]; + if (this._isPending[id]) continue; + this._invokeCb(id); + } + }, + unregister: function(id) { + delete this._callbacks[id]; + }, + isDispatching: function() { + return this._isDispatching; + }, + _startDispatching: function(payload) { + for (var id in this._callbacks) { + this._isPending[id] = false; + this._isHandled[id] = false; + } + this._pendingPayload = payload; + this._isDispatching = true; + }, + _stopDispatching: function() { + delete this._pendingPayload; + this._isDispatching = false; + }, + _invokeCb: function(id) { + this._isPending[id] = true; + this._callbacks[id](this._pendingPayload); + this._isHandled[id] = true; + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Emitter.js b/src/miniprogram_npm/miniprogram-licia/Emitter.js new file mode 100644 index 0000000..7412636 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Emitter.js @@ -0,0 +1,65 @@ +var Class = require('./Class'); +var has = require('./has'); +var each = require('./each'); +var slice = require('./slice'); +var once = require('./once'); +var clone = require('./clone'); +exports = Class( + { + initialize: function Emitter() { + this._events = this._events || {}; + }, + on: function(event, listener) { + this._events[event] = this._events[event] || []; + this._events[event].push(listener); + return this; + }, + off: function(event, listener) { + var events = this._events; + if (!has(events, event)) return; + var idx = events[event].indexOf(listener); + if (idx > -1) { + events[event].splice(idx, 1); + } + return this; + }, + once: function(event, listener) { + this.on(event, once(listener)); + return this; + }, + emit: function(event) { + var _this = this; + if (!has(this._events, event)) return; + var args = slice(arguments, 1); + var events = clone(this._events[event]); + each( + events, + function(val) { + return val.apply(_this, args); + }, + this + ); + return this; + }, + removeAllListeners: function(event) { + if (!event) { + this._events = {}; + } else { + delete this._events[event]; + } + return this; + } + }, + { + mixin: function(obj) { + each(['on', 'off', 'once', 'emit', 'removeAllListeners'], function( + val + ) { + obj[val] = exports.prototype[val]; + }); + obj._events = obj._events || {}; + } + } +); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Enum.js b/src/miniprogram_npm/miniprogram-licia/Enum.js new file mode 100644 index 0000000..7785e23 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Enum.js @@ -0,0 +1,31 @@ +var Class = require('./Class'); +var freeze = require('./freeze'); +var isArr = require('./isArr'); +var each = require('./each'); +var keys = require('./keys'); +exports = Class({ + initialize: function Enum(map) { + if (isArr(map)) { + this.size = map.length; + each( + map, + function(member, val) { + this[member] = val; + }, + this + ); + } else { + this.size = keys(map).length; + each( + map, + function(val, member) { + this[member] = val; + }, + this + ); + } + freeze(this); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/HashTable.js b/src/miniprogram_npm/miniprogram-licia/HashTable.js new file mode 100644 index 0000000..f5c61d4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/HashTable.js @@ -0,0 +1,61 @@ +var Class = require('./Class'); +var LinkedList = require('./LinkedList'); +var map = require('./map'); +var strHash = require('./strHash'); +var has = require('./has'); +exports = Class({ + initialize: function HashTable() { + var size = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : 32; + this._buckets = map(Array(size), function() { + return new LinkedList(); + }); + this._keys = {}; + }, + set: function(key, val) { + var keyHash = this._hash(key); + this._keys[key] = keyHash; + var linkedList = this._buckets[keyHash]; + var node = linkedList.find(function(val) { + return val.key === key; + }); + if (!node) { + linkedList.push({ + key: key, + value: val + }); + } else { + node.value.value = val; + } + }, + get: function(key) { + var linkedList = this._buckets[this._hash(key)]; + var node = linkedList.find(function(val) { + return val.key === key; + }); + if (node) { + return node.value.value; + } + }, + has: function(key) { + return has(this._keys, key); + }, + delete: function(key) { + var keyHash = this._hash(key); + delete this._keys[key]; + var linkedList = this._buckets[keyHash]; + var node = linkedList.find(function(val) { + return val.key === key; + }); + if (node) { + linkedList.rmNode(node); + } + }, + _hash: function(key) { + return strHash(key) % this._buckets.length; + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Heap.js b/src/miniprogram_npm/miniprogram-licia/Heap.js new file mode 100644 index 0000000..a687143 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Heap.js @@ -0,0 +1,79 @@ +var Class = require('./Class'); +var swap = require('./swap'); +var isSorted = require('./isSorted'); +exports = Class({ + initialize: function Heap() { + var cmp = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : isSorted.defComparator; + this._cmp = cmp; + this.clear(); + }, + clear: function() { + this._data = []; + this.size = 0; + }, + add: function(item) { + this._data.push(item); + this.size++; + this._heapifyUp(this.size - 1); + return this.size; + }, + poll: function() { + var data = this._data; + if (this.size > 0) { + var item = data[0]; + data[0] = data[this.size - 1]; + this.size--; + this._heapifyDown(0); + return item; + } + }, + peek: function() { + if (this.size > 0) { + return this._data[0]; + } + }, + _heapifyUp: function(idx) { + var data = this._data; + var parent = parentIdx(idx); + while (idx > 0 && this._cmp(data[parent], data[idx]) > 0) { + swap(data, parent, idx); + idx = parent; + parent = parentIdx(idx); + } + }, + _heapifyDown: function(idx) { + var size = this.size; + var cmp = this._cmp; + var data = this._data; + while (leftChildIdx(idx) < size) { + var smallerIdx = leftChildIdx(idx); + var rightChild = rightChildIdx(idx); + if ( + rightChild < size && + cmp(data[rightChildIdx], data[smallerIdx]) < 0 + ) { + smallerIdx = rightChild; + } + if (cmp(data[idx], data[smallerIdx]) < 0) { + break; + } else { + swap(data, idx, smallerIdx); + } + idx = smallerIdx; + } + } +}); +function parentIdx(idx) { + return Math.floor((idx - 1) / 2); +} +function leftChildIdx(idx) { + return 2 * idx + 1; +} +function rightChildIdx(idx) { + return 2 * idx + 2; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/HeapSnapshot.js b/src/miniprogram_npm/miniprogram-licia/HeapSnapshot.js new file mode 100644 index 0000000..d36a926 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/HeapSnapshot.js @@ -0,0 +1,111 @@ +var Class = require('./Class'); +var toBool = require('./toBool'); +var camelCase = require('./camelCase'); +var LinkedList = require('./LinkedList'); +var isStr = require('./isStr'); +var each = require('./each'); +var map = require('./map'); +exports = Class({ + initialize: function HeapSnapshot(profile) { + if (isStr(profile)) { + profile = JSON.parse(profile); + } + this.nodes = new LinkedList(); + this.edges = new LinkedList(); + var snapshot = profile.snapshot; + var meta = snapshot.meta; + this.nodeFields = map(meta.node_fields, camelCase); + this.nodeTypes = meta.node_types[this.nodeFields.indexOf('type')]; + this.edgeFields = map(meta.edge_fields, camelCase); + this.edgeTypes = meta.edge_types[this.edgeFields.indexOf('type')]; + this._init(profile); + }, + _init: function(profile) { + var _this = this; + var nodes = profile.nodes, + edges = profile.edges, + strings = profile.strings; + var nodeFields = this.nodeFields, + edgeFields = this.edgeFields; + var curEdgeIdx = 0; + var nodeFieldCount = nodeFields.length; + var edgeFieldCount = edgeFields.length; + var nodeMap = {}; + for (var i = 0, len = nodes.length; i < len; i += nodeFieldCount) { + var node = new Node(this); + node.init(nodes.slice(i, i + nodeFieldCount), strings); + this.nodes.push(node); + nodeMap[i] = node; + } + this.nodes.forEach(function(node) { + var edgeCount = node.edgeCount; + delete node.edgeCount; + var maxEdgeIdx = curEdgeIdx + edgeCount * edgeFieldCount; + for (var _i = curEdgeIdx; _i < maxEdgeIdx; _i += edgeFieldCount) { + var edge = new Edge(_this, node); + edge.init( + edges.slice(_i, _i + edgeFieldCount), + strings, + nodeMap + ); + _this.edges.push(edge); + } + curEdgeIdx = maxEdgeIdx; + }); + } +}); +var Node = Class({ + initialize: function Node(heapSnapshot) { + this._heapSnapshot = heapSnapshot; + }, + init: function(fields, strings) { + var _this2 = this; + var heapSnapshot = this._heapSnapshot; + var nodeFields = heapSnapshot.nodeFields, + nodeTypes = heapSnapshot.nodeTypes; + each(nodeFields, function(field, idx) { + var val = fields[idx]; + switch (field) { + case 'name': + val = strings[val]; + break; + case 'detachedness': + val = toBool(val); + break; + case 'type': + val = nodeTypes[val]; + break; + } + _this2[field] = val; + }); + } +}); +var Edge = Class({ + initialize: function Edge(heapSnapshot, fromNode) { + this._heapSnapshot = heapSnapshot; + this.fromNode = fromNode; + }, + init: function(fields, strings, nodeMap) { + var _this3 = this; + var heapSnapshot = this._heapSnapshot; + var edgeFields = heapSnapshot.edgeFields, + edgeTypes = heapSnapshot.edgeTypes; + each(edgeFields, function(field, idx) { + var val = fields[idx]; + switch (field) { + case 'nameOrIndex': + val = strings[val]; + break; + case 'type': + val = edgeTypes[val]; + break; + case 'toNode': + val = nodeMap[val]; + break; + } + _this3[field] = val; + }); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/I18n.js b/src/miniprogram_npm/miniprogram-licia/I18n.js new file mode 100644 index 0000000..75cdbc2 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/I18n.js @@ -0,0 +1,38 @@ +var Class = require('./Class'); +var safeGet = require('./safeGet'); +var extend = require('./extend'); +var strTpl = require('./strTpl'); +var isStr = require('./isStr'); +var isFn = require('./isFn'); +exports = Class({ + initialize: function I18n(locale, langs) { + this._locale = locale; + this._langs = langs; + }, + set: function(locale, lang) { + if (this._langs[locale]) { + extend(this._langs[locale], lang); + } else { + this._langs[locale] = lang; + } + }, + t: function(path, data) { + var val = ''; + var lang = this._langs[this._locale]; + if (!lang) return ''; + val = safeGet(lang, path); + if (data) { + if (isStr(val)) { + val = strTpl(val, data); + } else if (isFn(val)) { + val = val(data); + } + } + return val || ''; + }, + locale: function(locale) { + this._locale = locale; + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/JsonTransformer.js b/src/miniprogram_npm/miniprogram-licia/JsonTransformer.js new file mode 100644 index 0000000..2bdf4fe --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/JsonTransformer.js @@ -0,0 +1,68 @@ +var Class = require('./Class'); +var safeSet = require('./safeSet'); +var safeGet = require('./safeGet'); +var map = require('./map'); +var filter = require('./filter'); +var isFn = require('./isFn'); +var safeDel = require('./safeDel'); +var toArr = require('./toArr'); +var each = require('./each'); +exports = Class({ + className: 'JsonTransformer', + initialize: function(data) { + this._data = data || {}; + }, + set: function(key, val) { + if (arguments.length === 1) { + this._data = key; + return this; + } + safeSet(this._data, key, val); + return this; + }, + get: function(key) { + if (key == null) return this._data; + return safeGet(this._data, key); + }, + map: function(from, to, fn) { + if (isFn(from)) return this.set(map(this._data, from, this)); + if (isFn(to)) { + fn = to; + to = from; + } + return this.set(to, map(this.get(from), fn, this)); + }, + filter: function(from, to, fn) { + if (isFn(from)) return this.set(filter(this._data, from, this)); + if (isFn(to)) { + fn = to; + to = from; + } + return this.set(to, filter(this.get(from), fn, this)); + }, + remove: function(keys) { + keys = toArr(keys); + var data = this._data; + each(keys, function(key) { + safeDel(data, key); + }); + return this; + }, + compute: function(from, to, fn) { + if (isFn(from)) return this.set(from.call(this, this._data)); + if (isFn(to)) return this.set(from, to.call(this, this.get(from))); + from = map( + toArr(from), + function(key) { + return safeGet(this._data, key); + }, + this + ); + return this.set(to, fn.apply(this, from)); + }, + toString: function() { + return JSON.stringify(this._data); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/LinkedList.js b/src/miniprogram_npm/miniprogram-licia/LinkedList.js new file mode 100644 index 0000000..393b1cd --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/LinkedList.js @@ -0,0 +1,112 @@ +var Class = require('./Class'); +exports = Class({ + initialize: function LinkedList() { + this.tail = null; + this.head = null; + this.size = 0; + }, + push: function(val) { + var node = new Node(val, this.tail, null, this); + this.tail = node; + this.head = this.head || node; + this.size++; + return this.size; + }, + pop: function() { + if (!this.tail) return; + var node = this.tail; + this.tail = node.prev; + if (this.tail) { + this.tail.next = null; + } else { + this.head = null; + } + this.size--; + return node.value; + }, + unshift: function(val) { + var node = new Node(val, null, this.head, this); + this.head = node; + this.tail = this.tail || node; + this.size++; + return this.size; + }, + shift: function() { + if (!this.head) return; + var node = this.head; + this.head = node.next; + if (this.head) { + this.head.prev = null; + } else { + this.tail = null; + } + this.size--; + return node.value; + }, + rmNode: function(node) { + if (node.list !== this) { + throw Error('Node does not belong to this list'); + } + var next = node.next, + prev = node.prev; + if (next) { + next.prev = prev; + } + if (prev) { + prev.next = next; + } + if (node === this.head) { + this.head = next; + } + if (node === this.tail) { + this.tail = prev; + } + node.list = null; + node.prev = null; + node.next = null; + this.size--; + }, + find: function(fn) { + for (var i = 0, current = this.head; current !== null; i++) { + if (fn(current.value)) { + return current; + } + current = current.next; + } + }, + forEach: function(iterator, ctx) { + ctx = arguments.length > 1 ? ctx : this; + for (var i = 0, current = this.head; current !== null; i++) { + iterator.call(ctx, current.value, i, this); + current = current.next; + } + }, + toArr: function() { + var arr = new Array(this.size); + for (var i = 0, current = this.head; current !== null; i++) { + arr[i] = current.value; + current = current.next; + } + return arr; + } +}); +var Node = (exports.Node = Class({ + initialize: function Node(val, prev, next, list) { + this.value = val; + this.list = list; + if (prev) { + prev.next = this; + this.prev = prev; + } else { + this.prev = null; + } + if (next) { + next.prev = this; + this.next = next; + } else { + this.next = null; + } + } +})); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Logger.js b/src/miniprogram_npm/miniprogram-licia/Logger.js new file mode 100644 index 0000000..e7cf250 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Logger.js @@ -0,0 +1,69 @@ +var Emitter = require('./Emitter'); +var Enum = require('./Enum'); +var toArr = require('./toArr'); +var isUndef = require('./isUndef'); +var clone = require('./clone'); +var isStr = require('./isStr'); +var isNum = require('./isNum'); +exports = Emitter.extend( + { + initialize: function Logger(name, level) { + this.name = name; + this.setLevel(isUndef(level) ? exports.level.DEBUG : level); + this.callSuper(Emitter, 'initialize', arguments); + }, + setLevel: function(level) { + if (isStr(level)) { + level = exports.level[level.toUpperCase()]; + if (level) this._level = level; + return this; + } + if (isNum(level)) this._level = level; + return this; + }, + getLevel: function() { + return this._level; + }, + formatter: function(type, argList) { + return argList; + }, + trace: function() { + return this._log('trace', arguments); + }, + debug: function() { + return this._log('debug', arguments); + }, + info: function() { + return this._log('info', arguments); + }, + warn: function() { + return this._log('warn', arguments); + }, + error: function() { + return this._log('error', arguments); + }, + _log: function(type, argList) { + argList = toArr(argList); + if (argList.length === 0) return this; + this.emit('all', type, clone(argList)); + if (exports.level[type.toUpperCase()] < this._level) return this; + this.emit(type, clone(argList)); + + var consoleMethod = type === 'debug' ? console.log : console[type]; + consoleMethod.apply(console, this.formatter(type, argList)); + return this; + } + }, + { + level: new Enum({ + TRACE: 0, + DEBUG: 1, + INFO: 2, + WARN: 3, + ERROR: 4, + SILENT: 5 + }) + } +); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Lru.js b/src/miniprogram_npm/miniprogram-licia/Lru.js new file mode 100644 index 0000000..3624bd6 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Lru.js @@ -0,0 +1,63 @@ +var LinkedList = require('./LinkedList'); +var PseudoMap = require('./PseudoMap'); +var Class = require('./Class'); +exports = Class({ + initialize: function Lru(max) { + this._max = max; + this._list = new LinkedList(); + this._map = new PseudoMap(); + }, + has: function(key) { + return this._map.has(key); + }, + remove: function(key) { + var map = this._map; + if (this.has(key)) { + var node = map.get(key); + this._list.rmNode(node); + map.delete(key); + } + }, + get: function(key) { + var list = this._list; + var map = this._map; + var ret; + if (this.has(key)) { + var node = map.get(key); + ret = node.value.val; + list.rmNode(node); + list.unshift(node.value); + map.set(key, list.head); + } + return ret; + }, + set: function(key, val) { + var list = this._list; + var map = this._map; + if (this.has(key)) { + var node = map.get(key); + list.rmNode(node); + list.unshift({ + key: key, + val: val + }); + map.set(key, list.head); + } else { + list.unshift({ + key: key, + val: val + }); + map.set(key, list.head); + if (list.size > this._max) { + var item = list.pop(); + map.delete(item.key); + } + } + }, + clear: function() { + this._map = new PseudoMap(); + this._list = new LinkedList(); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/PriorityQueue.js b/src/miniprogram_npm/miniprogram-licia/PriorityQueue.js new file mode 100644 index 0000000..d6e2afc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/PriorityQueue.js @@ -0,0 +1,39 @@ +var Class = require('./Class'); +var Heap = require('./Heap'); +var isSorted = require('./isSorted'); +var wrap = require('./wrap'); +exports = Class({ + initialize: function PriorityQueue() { + var cmp = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : isSorted.defComparator; + this._heap = new Heap( + wrap(cmp, function(fn, a, b) { + return fn(a, b) * -1; + }) + ); + this.size = 0; + }, + clear: function() { + this._heap.clear(); + this.size = 0; + }, + enqueue: function(item) { + this._heap.add(item); + this.size++; + return this.size; + }, + dequeue: function() { + var item = this._heap.poll(); + if (item) { + this.size--; + return item; + } + }, + peek: function() { + return this._heap.peek(); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Promise.js b/src/miniprogram_npm/miniprogram-licia/Promise.js new file mode 100644 index 0000000..0f03eef --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Promise.js @@ -0,0 +1,178 @@ +var Class = require('./Class'); +var isObj = require('./isObj'); +var isFn = require('./isFn'); +var State = require('./State'); +var bind = require('./bind'); +var nextTick = require('./nextTick'); +var noop = require('./noop'); +var toArr = require('./toArr'); +var Promise = (exports = Class( + { + initialize: function Promise(fn) { + if (!isObj(this)) + throw new TypeError('Promises must be constructed via new'); + if (!isFn(fn)) throw new TypeError(fn + ' is not a function'); + var self = this; + this._state = new State('pending', { + fulfill: { + from: 'pending', + to: 'fulfilled' + }, + reject: { + from: 'pending', + to: 'rejected' + }, + adopt: { + from: 'pending', + to: 'adopted' + } + }) + .on('fulfill', assignVal) + .on('reject', assignVal) + .on('adopt', assignVal); + function assignVal(val) { + self._value = val; + } + this._handled = false; + this._value = undefined; + this._deferreds = []; + doResolve(fn, this); + }, + catch: function(onRejected) { + return this.then(null, onRejected); + }, + then: function(onFulfilled, onRejected) { + var promise = new Promise(noop); + handle(this, new Handler(onFulfilled, onRejected, promise)); + return promise; + } + }, + { + all: function(arr) { + var args = toArr(arr); + return new Promise(function(resolve, reject) { + if (args.length === 0) return resolve([]); + var remaining = args.length; + function res(i, val) { + try { + if (val && (isObj(val) || isFn(val))) { + var then = val.then; + if (isFn(then)) { + then.call( + val, + function(val) { + res(i, val); + }, + reject + ); + return; + } + } + args[i] = val; + if (--remaining === 0) resolve(args); + } catch (e) { + reject(e); + } + } + for (var i = 0; i < args.length; i++) res(i, args[i]); + }); + }, + resolve: function(val) { + if (val && isObj(val) && val.constructor === Promise) return val; + return new Promise(function(resolve) { + resolve(val); + }); + }, + reject: function(val) { + return new Promise(function(resolve, reject) { + reject(val); + }); + }, + race: function(values) { + return new Promise(function(resolve, reject) { + for (var i = 0, len = values.length; i < len; i++) { + values[i].then(resolve, reject); + } + }); + } + } +)); +var Handler = Class({ + initialize: function Handler(onFulfilled, onRejected, promise) { + this.onFulfilled = isFn(onFulfilled) ? onFulfilled : null; + this.onRejected = isFn(onRejected) ? onRejected : null; + this.promise = promise; + } +}); +function reject(self, err) { + self._state.reject(err); + finale(self); +} +function resolve(self, val) { + try { + if (val === self) + throw new TypeError('A promise cannot be resolved with itself'); + if (val && (isObj(val) || isFn(val))) { + var then = val.then; + if (val instanceof Promise) { + self._state.adopt(val); + return finale(self); + } + if (isFn(then)) return doResolve(bind(then, val), self); + } + self._state.fulfill(val); + finale(self); + } catch (e) { + reject(self, e); + } +} +function finale(self) { + for (var i = 0, len = self._deferreds.length; i < len; i++) { + handle(self, self._deferreds[i]); + } + self._deferreds = null; +} +function handle(self, deferred) { + while (self._state.is('adopted')) self = self._value; + if (self._state.is('pending')) return self._deferreds.push(deferred); + self._handled = true; + nextTick(function() { + var isFulfilled = self._state.is('fulfilled'); + var cb = isFulfilled ? deferred.onFulfilled : deferred.onRejected; + if (cb === null) + return (isFulfilled ? resolve : reject)( + deferred.promise, + self._value + ); + var ret; + try { + ret = cb(self._value); + } catch (e) { + return reject(deferred.promise, e); + } + resolve(deferred.promise, ret); + }); +} +function doResolve(fn, self) { + var done = false; + try { + fn( + function(val) { + if (done) return; + done = true; + resolve(self, val); + }, + function(reason) { + if (done) return; + done = true; + reject(self, reason); + } + ); + } catch (e) { + if (done) return; + done = true; + reject(self, e); + } +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/PseudoMap.js b/src/miniprogram_npm/miniprogram-licia/PseudoMap.js new file mode 100644 index 0000000..1036911 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/PseudoMap.js @@ -0,0 +1,64 @@ +var Class = require('./Class'); +var root = require('./root'); +var defineProp = require('./defineProp'); +var keys = require('./keys'); +var each = require('./each'); +var isArr = require('./isArr'); +var isUndef = require('./isUndef'); +if (root.Map && !false) { + exports = root.Map; +} else { + exports = Class({ + initialize: function PseudoMap(data) { + this.clear(); + var self = this; + defineProp(this, 'size', { + get: function() { + return keys(self._data).length; + }, + set: function() {}, + enumerable: true, + configurable: true + }); + if (data instanceof exports) { + data.forEach(function(val, key) { + this.set(key, val); + }, this); + } else if (isArr(data)) { + each( + data, + function(val) { + this.set(val[0], val[1]); + }, + this + ); + } + }, + forEach: function(fn, ctx) { + each( + this._data, + function(val, key) { + fn.call(this, val, key); + }, + ctx + ); + }, + has: function(key) { + return !isUndef(this._data[key]); + }, + get: function(key) { + return this._data[key]; + }, + set: function(key, val) { + this._data[key] = val; + }, + delete: function(key) { + delete this._data[key]; + }, + clear: function() { + this._data = {}; + } + }); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Queue.js b/src/miniprogram_npm/miniprogram-licia/Queue.js new file mode 100644 index 0000000..ab3b5e9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Queue.js @@ -0,0 +1,35 @@ +var Class = require('./Class'); +exports = Class({ + initialize: function Queue() { + this.clear(); + }, + clear: function() { + this._items = []; + this.size = 0; + }, + enqueue: function(item) { + this._items.push(item); + return ++this.size; + }, + dequeue: function() { + if (!this.size) return; + this.size--; + return this._items.shift(); + }, + peek: function() { + if (!this.size) return; + return this._items[0]; + }, + forEach: function(iterator, ctx) { + ctx = arguments.length > 1 ? ctx : this; + var items = this._items; + for (var i = 0, size = this.size; i < size; i++) { + iterator.call(ctx, items[i], i, this); + } + }, + toArr: function() { + return this._items.slice(0); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/QuickLru.js b/src/miniprogram_npm/miniprogram-licia/QuickLru.js new file mode 100644 index 0000000..4c01e78 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/QuickLru.js @@ -0,0 +1,49 @@ +var isUndef = require('./isUndef'); +var Class = require('./Class'); +exports = Class({ + initialize: function QuickLru(max) { + this._max = max; + this._cache = {}; + this._oldCache = {}; + this._size = 0; + }, + has: function(key) { + return !isUndef(this._cache[key]) || !isUndef(this._oldCache[key]); + }, + remove: function(key) { + if (!isUndef(this._cache[key])) this._cache[key] = undefined; + if (!isUndef(this._oldCache[key])) this._oldCache[key] = undefined; + }, + get: function(key) { + if (!isUndef(this._cache[key])) { + return this._cache[key]; + } + var val = this._oldCache[key]; + if (!isUndef(val)) { + this._update(key, val); + return val; + } + }, + set: function(key, val) { + if (!isUndef(this._cache[key])) { + this._cache[key] = val; + } else { + this._update(key, val); + } + }, + clear: function() { + this._cache = {}; + this._oldCache = {}; + }, + _update: function(key, val) { + this._cache[key] = val; + this._size++; + if (this._size > this._max) { + this._size = 0; + this._oldCache = this._cache; + this._cache = {}; + } + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Readiness.js b/src/miniprogram_npm/miniprogram-licia/Readiness.js new file mode 100644 index 0000000..638974e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Readiness.js @@ -0,0 +1,59 @@ +var Class = require('./Class'); +var toArr = require('./toArr'); +var each = require('./each'); +var map = require('./map'); +var noop = require('./noop'); +var some = require('./some'); +exports = Class({ + initialize: function Readiness() { + this._promises = {}; + this._resolves = {}; + this._states = {}; + }, + signal: function(tasks) { + var states = this._states; + each(this._getPromises(toArr(tasks)), function(val) { + if (!val.state) { + states[val.task] = true; + val.resolve(); + } + }); + }, + isReady: function(tasks) { + return !some(this._getPromises(toArr(tasks)), function(val) { + return !val.state; + }); + }, + ready: function(tasks) { + var fn = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : noop; + return Promise.all( + map(this._getPromises(toArr(tasks)), function(val) { + return val.promise; + }) + ).then(fn); + }, + _getPromises: function(tasks) { + var promises = this._promises; + var resolves = this._resolves; + var states = this._states; + return map(tasks, function(task) { + if (!promises[task]) { + promises[task] = new Promise(function(resolve) { + resolves[task] = resolve; + states[task] = false; + }); + } + return { + task: task, + promise: promises[task], + resolve: resolves[task], + state: states[task] + }; + }); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/ReduceStore.js b/src/miniprogram_npm/miniprogram-licia/ReduceStore.js new file mode 100644 index 0000000..543cb77 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/ReduceStore.js @@ -0,0 +1,41 @@ +var Class = require('./Class'); +var clone = require('./clone'); +var remove = require('./remove'); +exports = Class({ + initialize: function ReduceStore(reducer, initialState) { + this._reducer = reducer; + this._state = initialState; + this._curListeners = []; + this._nextListeners = this._curListeners; + }, + subscribe: function(listener) { + var isSubscribed = true; + this._ensureCanMutateNextListeners(); + this._nextListeners.push(listener); + var self = this; + return function() { + if (!isSubscribed) return; + isSubscribed = false; + self._ensureCanMutateNextListeners(); + remove(self._nextListeners, function(val) { + return val === listener; + }); + }; + }, + dispatch: function(action) { + this._state = this._reducer(this._state, action); + var listeners = (this._curListeners = this._nextListeners); + for (var i = 0, len = listeners.length; i < len; i++) listeners[i](); + return action; + }, + getState: function() { + return this._state; + }, + _ensureCanMutateNextListeners: function() { + if (this._nextListeners === this._curListeners) { + this._nextListeners = clone(this._curListeners); + } + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Semaphore.js b/src/miniprogram_npm/miniprogram-licia/Semaphore.js new file mode 100644 index 0000000..3beb419 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Semaphore.js @@ -0,0 +1,28 @@ +var Class = require('./Class'); +var Queue = require('./Queue'); +exports = Class({ + initialize: function Semaphore() { + var counter = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : 1; + this._counter = counter; + this._tasks = new Queue(); + }, + wait: function(fn) { + if (this._counter > 0) { + this._counter--; + return fn(); + } + this._tasks.enqueue(fn); + }, + signal: function() { + var task = this._tasks.dequeue(); + if (task) { + return task(); + } + this._counter++; + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/SingleEmitter.js b/src/miniprogram_npm/miniprogram-licia/SingleEmitter.js new file mode 100644 index 0000000..a76bda4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/SingleEmitter.js @@ -0,0 +1,48 @@ +var Class = require('./Class'); +var clone = require('./clone'); +var each = require('./each'); +var toArr = require('./toArr'); +exports = Class( + { + initialize: function SingleEmitter() { + this._listeners = []; + }, + addListener: function(listener) { + this._listeners.push(listener); + }, + rmListener: function(listener) { + var idx = this._listeners.indexOf(listener); + if (idx > -1) { + this._listeners.splice(idx, 1); + } + }, + rmAllListeners: function() { + this._listeners = []; + }, + emit: function() { + var _this = this; + var args = toArr(arguments); + var listeners = clone(this._listeners); + each( + listeners, + function(listener) { + return listener.apply(_this, args); + }, + this + ); + } + }, + { + mixin: function(obj) { + each( + ['addListener', 'rmListener', 'emit', 'rmAllListeners'], + function(val) { + obj[val] = exports.prototype[val]; + } + ); + obj._listeners = obj._listeners || []; + } + } +); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Stack.js b/src/miniprogram_npm/miniprogram-licia/Stack.js new file mode 100644 index 0000000..8341b4d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Stack.js @@ -0,0 +1,35 @@ +var Class = require('./Class'); +var reverse = require('./reverse'); +exports = Class({ + initialize: function Stack() { + this.clear(); + }, + clear: function() { + this._items = []; + this.size = 0; + }, + push: function(item) { + this._items.push(item); + return ++this.size; + }, + pop: function() { + if (!this.size) return; + this.size--; + return this._items.pop(); + }, + peek: function() { + return this._items[this.size - 1]; + }, + forEach: function(iterator, ctx) { + ctx = arguments.length > 1 ? ctx : this; + var items = this._items; + for (var i = this.size - 1, j = 0; i >= 0; i--, j++) { + iterator.call(ctx, items[i], j, this); + } + }, + toArr: function() { + return reverse(this._items); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/State.js b/src/miniprogram_npm/miniprogram-licia/State.js new file mode 100644 index 0000000..7bd98d6 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/State.js @@ -0,0 +1,45 @@ +var Emitter = require('./Emitter'); +var each = require('./each'); +var some = require('./some'); +var toArr = require('./toArr'); +exports = Emitter.extend({ + className: 'State', + initialize: function(initial, events) { + this.callSuper(Emitter, 'initialize'); + this.current = initial; + var self = this; + each(events, function(event, key) { + self[key] = buildEvent(key, event); + }); + }, + is: function(state) { + return this.current === state; + } +}); +function buildEvent(name, event) { + var from = toArr(event.from); + var to = event.to; + return function() { + var args = toArr(arguments); + args.unshift(name); + var hasEvent = some( + from, + function(val) { + return this.current === val; + }, + this + ); + if (hasEvent) { + this.current = to; + this.emit.apply(this, args); + } else { + this.emit( + 'error', + new Error(this.current + ' => ' + to + ' error'), + name + ); + } + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Store.js b/src/miniprogram_npm/miniprogram-licia/Store.js new file mode 100644 index 0000000..f02a055 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Store.js @@ -0,0 +1,58 @@ +var Emitter = require('./Emitter'); +var isStr = require('./isStr'); +var isObj = require('./isObj'); +var each = require('./each'); +var toArr = require('./toArr'); +exports = Emitter.extend({ + initialize: function Store(data) { + this.callSuper(Emitter, 'initialize', arguments); + this._data = data || {}; + this.save(this._data); + }, + set: function(key, val) { + var data; + if (isStr(key)) { + data = {}; + data[key] = val; + } else if (isObj(key)) { + data = key; + } + var self = this; + each(data, function(val, key) { + var oldVal = self._data[key]; + self._data[key] = val; + self.emit('change', key, val, oldVal); + }); + this.save(this._data); + }, + get: function(key) { + var data = this._data; + if (isStr(key)) return data[key]; + var ret = {}; + each(key, function(val) { + ret[val] = data[val]; + }); + return ret; + }, + remove: function(key) { + key = toArr(key); + var data = this._data; + each(key, function(val) { + delete data[val]; + }); + this.save(data); + }, + clear: function() { + this._data = {}; + this.save(this._data); + }, + each: function(fn) { + each(this._data, fn); + }, + + save: function(data) { + this._data = data; + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Trace.js b/src/miniprogram_npm/miniprogram-licia/Trace.js new file mode 100644 index 0000000..e980181 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Trace.js @@ -0,0 +1,157 @@ +var Class = require('./Class'); +var each = require('./each'); +var map = require('./map'); +exports = Class({ + initialize: function Trace() { + var _this = this; + var events = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : []; + this._processes = {}; + each(events, function(event) { + return _this.addEvent(event); + }); + }, + addEvent: function(event) { + var process = this.getProcess(event.pid); + process.addEvent(event); + }, + rmEvent: function(event) { + var process = this.getProcess(event.pid); + process.rmEvent(event); + }, + getProcess: function(id) { + var process = this._processes[id]; + if (!process) { + process = new Process(id); + this._processes[id] = process; + } + return process; + }, + rmProcess: function(id) { + delete this._processes[id]; + }, + processes: function() { + return map(this._processes); + }, + toJSON: function() { + var events = []; + each(this.processes(), function(process) { + events.push.apply(events, process.toJSON()); + }); + return events; + } +}); +var Process = Class({ + initialize: function Process(id) { + this._id = id; + this._name = ''; + this._threads = {}; + this._metadata = {}; + }, + id: function() { + return this._id; + }, + name: function() { + return this._name; + }, + addEvent: function(event) { + if (event.cat === '__metadata') { + if (event.name === 'process_name') { + this._name = event.args.name; + } + if (event.tid === 0) { + this._metadata[event.name] = event.args; + return; + } + } + var thread = this.getThread(event.tid); + thread.addEvent(event); + }, + rmEvent: function(event) { + var thread = this.getThread(event.tid); + thread.rmEvent(event); + }, + getThread: function(id) { + var thread = this._threads[id]; + if (!thread) { + thread = new Thread(id, this.id()); + this._threads[id] = thread; + } + return thread; + }, + rmThread: function(id) { + delete this._threads[id]; + }, + threads: function() { + return map(this._threads); + }, + toJSON: function() { + var _this2 = this; + var events = []; + each(this._metadata, function(args, name) { + events.push(createMetaEvent(_this2._id, 0, name, args)); + }); + each(this.threads(), function(thread) { + events.push.apply(events, thread.toJSON()); + }); + return events; + } +}); +var Thread = Class({ + initialize: function Thread(id, pid) { + this._id = id; + this._pid = pid; + this._name = ''; + this._events = []; + this._metadata = {}; + }, + id: function() { + return this._id; + }, + name: function() { + return this._name; + }, + addEvent: function(event) { + if (event.cat === '__metadata') { + if (event.name === 'thread_name') { + this._name = event.args.name; + } + this._metadata[event.name] = event.args; + return; + } + this._events.push(event); + }, + rmEvent: function(event) { + var events = this._events; + events.splice(events.indexOf(event), 1); + }, + events: function() { + return map(this._events); + }, + toJSON: function() { + var _this3 = this; + var events = []; + each(this._metadata, function(args, name) { + events.push(createMetaEvent(_this3._pid, _this3._id, name, args)); + }); + each(this.events(), function(event) { + events.push(event); + }); + return events; + } +}); +function createMetaEvent(pid, tid, name, args) { + return { + args: args, + cat: '__metadata', + name: name, + ph: 'M', + pid: pid, + tid: tid, + ts: 0 + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Tracing.js b/src/miniprogram_npm/miniprogram-licia/Tracing.js new file mode 100644 index 0000000..17ecfa6 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Tracing.js @@ -0,0 +1,227 @@ +var Class = require('./Class'); +var Trace = require('./Trace'); +var perfNow = require('./perfNow'); +var extend = require('./extend'); +var isNode = require('./isNode'); +var Stack = require('./Stack'); +var map = require('./map'); +var trim = require('./trim'); +var isEmpty = require('./isEmpty'); +var intersect = require('./intersect'); +var convertBase = require('./convertBase'); +var defPid = 0; +var defTid = 0; +var id = 0; +if (isNode) { + defPid = process.pid; + try { + defTid = eval('require')('worker_threads').threadId; + } catch (e) {} +} +exports = Class({ + initialize: function Tracing() { + var _ref = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : {}, + _ref$pid = _ref.pid, + pid = _ref$pid === void 0 ? defPid : _ref$pid, + _ref$tid = _ref.tid, + tid = _ref$tid === void 0 ? defTid : _ref$tid, + _ref$processName = _ref.processName, + processName = + _ref$processName === void 0 ? 'Process' : _ref$processName, + _ref$threadName = _ref.threadName, + threadName = + _ref$threadName === void 0 ? 'Thread' : _ref$threadName; + this._pid = pid; + this._tid = tid; + this._processName = processName; + this._threadName = threadName; + }, + start: function() { + var cat = + arguments.length > 0 && arguments[0] !== undefined + ? arguments[0] + : ''; + this._targetCat = processCat(cat); + if (!isEmpty(this._targetCat)) { + this._targetCat.push('__metadata'); + } + this._traceEventStack = new Stack(); + this._asyncEventMap = {}; + this._trace = new Trace(); + this.metadata( + 'process_name', + { + name: this._processName + }, + { + tid: 0, + ts: 0 + } + ); + this.metadata( + 'thread_name', + { + name: this._threadName + }, + { + ts: 0 + } + ); + }, + stop: function() { + var trace = this._trace; + if (!trace) { + throw Error('Need to call start first'); + } + delete this._targetCat; + delete this._traceEventStack; + delete this._asyncEventMap; + delete this._trace; + return trace.toJSON(); + }, + metadata: function(name, args, extra) { + this._addEvent('__metadata', name, Phase.Metadata, args, extra); + }, + begin: function(cat, name) { + var args = + arguments.length > 2 && arguments[2] !== undefined + ? arguments[2] + : {}; + if (!this._traceEventStack) { + return; + } + this._traceEventStack.push({ + cat: cat, + name: name, + args: args, + ts: this._getCurTs() + }); + }, + end: function(args) { + if (!this._traceEventStack) { + return; + } + var beginEvent = this._traceEventStack.pop(); + if (!beginEvent) { + throw Error('Need to call begin first'); + } + var cat = beginEvent.cat, + name = beginEvent.name, + ts = beginEvent.ts; + args = extend(beginEvent.args, args); + this._addEvent(cat, name, Phase.Complete, args, { + dur: this._getCurTs() - ts, + ts: ts + }); + }, + asyncBegin: function(cat, name) { + var id = + arguments.length > 2 && arguments[2] !== undefined + ? arguments[2] + : this.id(); + var args = + arguments.length > 3 && arguments[3] !== undefined + ? arguments[3] + : {}; + if (!this._asyncEventMap) { + return id; + } + this._asyncEventMap[id] = { + cat: cat, + name: name + }; + this._addEvent(cat, name, Phase.NestableAsyncBegin, args, { + id: id + }); + return id; + }, + asyncEnd: function(id) { + var args = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : {}; + if (!this._asyncEventMap) { + return; + } + var asyncBeginEvent = this._asyncEventMap[id]; + if (!asyncBeginEvent) { + throw Error('Need to call async begin first'); + } + var cat = asyncBeginEvent.cat, + name = asyncBeginEvent.name; + delete this._asyncEventMap[id]; + this._addEvent(cat, name, Phase.NestableAsyncEnd, args, { + id: id + }); + }, + instant: function(cat, name) { + var scope = + arguments.length > 2 && arguments[2] !== undefined + ? arguments[2] + : 't'; + var args = arguments.length > 3 ? arguments[3] : undefined; + this._addEvent(cat, name, Phase.Instant, args, { + s: scope + }); + }, + id: function() { + return '0x' + convertBase(id++, 10, 16); + }, + _addEvent: function(cat, name, ph) { + var args = + arguments.length > 3 && arguments[3] !== undefined + ? arguments[3] + : {}; + var extra = + arguments.length > 4 && arguments[4] !== undefined + ? arguments[4] + : {}; + if (!this._trace) { + return; + } + var targetCat = this._targetCat; + if (!isEmpty(targetCat)) { + var catArr = processCat(cat); + if (isEmpty(intersect(catArr, targetCat))) { + return; + } + } + var event = extend( + { + name: name, + cat: cat, + ph: ph, + ts: this._getCurTs(), + pid: this._pid, + tid: this._tid, + args: args + }, + extra + ); + this._trace.addEvent(event); + }, + _getCurTs: function() { + return Math.round(perfNow() * 1000); + } +}); +var Phase = { + Begin: 'B', + End: 'E', + Complete: 'X', + Instant: 'I', + NestableAsyncBegin: 'b', + NestableAsyncEnd: 'e', + Metadata: 'M' +}; +function processCat(cat) { + cat = trim(cat); + if (cat === '') { + return []; + } + return map(cat.split(','), trim); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Trie.js b/src/miniprogram_npm/miniprogram-licia/Trie.js new file mode 100644 index 0000000..2fd8191 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Trie.js @@ -0,0 +1,90 @@ +var Class = require('./Class'); +var each = require('./each'); + +exports = Class({ + initialize: function Trie() { + this.clear(); + }, + add: function(word) { + var edges = this._edges; + var node = this._root; + this._wordsInSubtree[node]++; + for (var i = 0, len = word.length; i < len; i++) { + var edge = word[i]; + var next = edges[node][edge]; + if (!next) { + if (this._freeNodes.length) { + next = this._freeNodes.pop(); + } else { + next = this._idx++; + this._isWord.push(false); + this._wordsInSubtree.push(0); + edges.push({}); + } + edges[node][edge] = next; + } + this._wordsInSubtree[next]++; + node = next; + } + this._isWord[node] = true; + }, + remove: function(word) { + if (!this.has(word)) { + return; + } + var node = this._root; + this._wordsInSubtree[node]--; + for (var i = 0, len = word.length; i < len; i++) { + var edge = word[i]; + var next = this._edges[node][edge]; + if (!--this._wordsInSubtree[next]) { + delete this._edges[node][edge]; + this._freeNodes.push(next); + } + node = next; + } + this._isWord[node] = false; + }, + has: function(word) { + var node = this._root; + for (var i = 0, len = word.length; i < len; i++) { + node = this._edges[node][word[i]]; + if (!node) { + return false; + } + } + return this._isWord[node]; + }, + words: function(prefix) { + var node = this._root; + for (var i = 0, len = prefix.length; i < len; i++) { + node = this._edges[node][prefix[i]]; + if (!node) { + return []; + } + } + var result = []; + this._dfs(node, prefix, result); + return result; + }, + clear: function() { + this._idx = 1; + this._root = 0; + this._edges = [{}]; + this._isWord = [false]; + this._wordsInSubtree = [0]; + this._freeNodes = []; + }, + _dfs: function(node, prefix, result) { + var _this = this; + if (this._isWord[node]) { + result.push(prefix); + } + var edges = this._edges[node]; + each(edges, function(node, edge) { + return _this._dfs(node, prefix + edge, result); + }); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Tween.js b/src/miniprogram_npm/miniprogram-licia/Tween.js new file mode 100644 index 0000000..8964fa5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Tween.js @@ -0,0 +1,98 @@ +var Emitter = require('./Emitter'); +var State = require('./State'); +var easing = require('./easing'); +var now = require('./now'); +var each = require('./each'); +var raf = require('./raf'); +var isFn = require('./isFn'); +exports = Emitter.extend({ + className: 'Tween', + initialize: function(target) { + this.callSuper(Emitter, 'initialize', arguments); + this._target = target; + this._dest = {}; + this._duration = 0; + this._progress = 0; + this._origin = {}; + this._diff = {}; + this._ease = easing['linear']; + this._state = new State('pause', { + play: { + from: 'pause', + to: 'play' + }, + pause: { + from: 'play', + to: 'pause' + } + }); + }, + to: function(props, duration, ease) { + var origin = {}; + var target = this._target; + var diff = {}; + ease = ease || this._ease; + this._dest = props; + this._duration = duration || this._duration; + this._ease = isFn(ease) ? ease : easing[ease]; + each(props, function(val, key) { + origin[key] = target[key]; + diff[key] = val - origin[key]; + }); + this._origin = origin; + this._diff = diff; + return this; + }, + progress: function(progress) { + var ease = this._ease; + var target = this._target; + var origin = this._origin; + var diff = this._diff; + var dest = this._dest; + var self = this; + if (progress != null) { + progress = progress < 1 ? progress : 1; + this._progress = progress; + each(dest, function(val, key) { + target[key] = origin[key] + diff[key] * ease(progress); + }); + self.emit('update', target); + return this; + } + return this._progress; + }, + play: function() { + var state = this._state; + if (state.is('play')) return; + state.play(); + var startTime = now(); + var progress = this._progress; + var duration = this._duration * (1 - progress); + var target = this._target; + var self = this; + function render() { + if (state.is('pause')) return; + var time = now(); + self.progress(progress + (time - startTime) / duration); + if (self._progress === 1) { + state.pause(); + self.emit('end', target); + return; + } + raf(render); + } + raf(render); + return this; + }, + pause: function() { + var state = this._state; + if (state.is('pause')) return; + state.pause(); + return this; + }, + paused: function() { + return this._state.is('pause'); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Url.js b/src/miniprogram_npm/miniprogram-licia/Url.js new file mode 100644 index 0000000..45a6d07 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Url.js @@ -0,0 +1,125 @@ +var Class = require('./Class'); +var extend = require('./extend'); +var trim = require('./trim'); +var query = require('./query'); +var isEmpty = require('./isEmpty'); +var each = require('./each'); +var isArr = require('./isArr'); +var toArr = require('./toArr'); +var isBrowser = require('./isBrowser'); +var isObj = require('./isObj'); +var toStr = require('./toStr'); +exports = Class( + { + className: 'Url', + initialize: function(url) { + if (!url && isBrowser) url = window.location.href; + extend(this, exports.parse(url || '')); + }, + setQuery: function(name, val) { + var query = this.query; + if (isObj(name)) { + each(name, function(val, key) { + query[key] = toStr(val); + }); + } else { + query[name] = toStr(val); + } + return this; + }, + rmQuery: function(name) { + var query = this.query; + if (!isArr(name)) name = toArr(name); + each(name, function(key) { + delete query[key]; + }); + return this; + }, + toString: function() { + return exports.stringify(this); + } + }, + { + parse: function(url) { + var ret = { + protocol: '', + auth: '', + hostname: '', + hash: '', + query: {}, + port: '', + pathname: '', + slashes: false + }; + var rest = trim(url); + var slashes = false; + var proto = rest.match(regProto); + if (proto) { + proto = proto[0]; + ret.protocol = proto.toLowerCase(); + rest = rest.substr(proto.length); + } + if (proto) { + slashes = rest.substr(0, 2) === '//'; + if (slashes) { + rest = rest.slice(2); + ret.slashes = true; + } + } + if (slashes) { + var host = rest; + var hostEnd = -1; + for (var i = 0, len = hostEndingChars.length; i < len; i++) { + var pos = rest.indexOf(hostEndingChars[i]); + if (pos !== -1 && (hostEnd === -1 || pos < hostEnd)) + hostEnd = pos; + } + if (hostEnd > -1) { + host = rest.slice(0, hostEnd); + rest = rest.slice(hostEnd); + } + var atSign = host.lastIndexOf('@'); + if (atSign !== -1) { + ret.auth = decodeURIComponent(host.slice(0, atSign)); + host = host.slice(atSign + 1); + } + ret.hostname = host; + var port = host.match(regPort); + if (port) { + port = port[0]; + if (port !== ':') ret.port = port.substr(1); + ret.hostname = host.substr(0, host.length - port.length); + } + } + var hash = rest.indexOf('#'); + if (hash !== -1) { + ret.hash = rest.substr(hash); + rest = rest.slice(0, hash); + } + var queryMark = rest.indexOf('?'); + if (queryMark !== -1) { + ret.query = query.parse(rest.substr(queryMark + 1)); + rest = rest.slice(0, queryMark); + } + ret.pathname = rest || '/'; + return ret; + }, + stringify: function(obj) { + var ret = + obj.protocol + + (obj.slashes ? '//' : '') + + (obj.auth ? encodeURIComponent(obj.auth) + '@' : '') + + obj.hostname + + (obj.port ? ':' + obj.port : '') + + obj.pathname; + if (!isEmpty(obj.query)) ret += '?' + query.stringify(obj.query); + if (obj.hash) ret += obj.hash; + return ret; + } + } +); +var regProto = /^([a-z0-9.+-]+:)/i; +var regPort = /:[0-9]*$/; +var hostEndingChars = ['/', '?', '#']; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Validator.js b/src/miniprogram_npm/miniprogram-licia/Validator.js new file mode 100644 index 0000000..8db3038 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Validator.js @@ -0,0 +1,82 @@ +var Class = require('./Class'); +var keys = require('./keys'); +var safeGet = require('./safeGet'); +var isFn = require('./isFn'); +var isUndef = require('./isUndef'); +var isNum = require('./isNum'); +var isStr = require('./isStr'); +var isBool = require('./isBool'); +exports = Class( + { + className: 'Validator', + initialize: function(options) { + this._options = options; + this._optKeys = keys(options); + }, + validate: function(obj) { + obj = obj || {}; + var options = this._options; + var objKeys = this._optKeys; + for (var i = 0, len = objKeys.length; i < len; i++) { + var key = objKeys[i]; + var result = this._validateVal( + safeGet(obj, key), + options[key], + key + ); + if (result !== true) return result; + } + return true; + }, + _validateVal: function(val, rules, objKey) { + var plugins = exports.plugins; + if (isFn(rules)) return rules(val); + var ruleKeys = keys(rules); + for (var i = 0, len = ruleKeys.length; i < len; i++) { + var key = ruleKeys[i]; + var config = rules[key]; + var result = true; + if (isFn(config)) result = config(val, objKey); + var plugin = plugins[key]; + if (plugin) result = plugin(val, objKey, config); + if (result !== true) return result; + } + return true; + } + }, + { + plugins: { + required: function(val, key, config) { + if (config && isUndef(val)) return key + ' is required'; + return true; + }, + number: function(val, key, config) { + if (config && !isUndef(val) && !isNum(val)) + return key + ' should be a number'; + return true; + }, + boolean: function(val, key, config) { + if (config && !isUndef(val) && !isBool(val)) + return key + ' should be a boolean'; + return true; + }, + string: function(val, key, config) { + if (config && !isUndef(val) && !isStr(val)) + return key + ' should be a string'; + return true; + }, + regexp: function(val, key, config) { + if (isStr(val) && !config.test(val)) + return ( + key + ' should match given regexp ' + config.toString() + ); + return true; + } + }, + addPlugin: function(name, plugin) { + exports.plugins[name] = plugin; + } + } +); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/Wrr.js b/src/miniprogram_npm/miniprogram-licia/Wrr.js new file mode 100644 index 0000000..ae3eb57 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/Wrr.js @@ -0,0 +1,86 @@ +var Class = require('./Class'); +var max = require('./max'); +var map = require('./map'); +var reduce = require('./reduce'); +var gcd = require('./gcd'); +var filter = require('./filter'); +exports = Class({ + initialize: function Wrr() { + this._peers = []; + }, + set: function(val, weight) { + var peers = this._peers; + var size = this.size; + for (var i = 0; i < size; i++) { + var peer = peers[i]; + if (peer.val === val) { + peer.weight = weight; + this._reset(); + return; + } + } + peers.push({ + val: val, + weight: weight + }); + this._reset(); + }, + get: function(val) { + var peers = this._peers; + var size = this.size; + for (var i = 0; i < size; i++) { + var peer = peers[i]; + if (peer.val === val) { + return peer.weight; + } + } + }, + remove: function(val) { + this._peers = filter(this._peers, function(peer) { + return peer.val !== val; + }); + this._reset(); + }, + next: function() { + var peers = this._peers; + var size = this.size; + if (size === 0) return; + + while (true) { + this._i = (this._i + 1) % size; + if (this._i === 0) { + this._cw = this._cw - this._gcdS; + if (this._cw <= 0) { + this._cw = this._maxS; + } + } + if (this._cw === 0) return; + if (peers[this._i].weight >= this._cw) { + return peers[this._i].val; + } + } + }, + clear: function() { + this._peers = []; + this._reset(); + }, + _reset: function() { + var peers = this._peers; + this.size = peers.length; + var weights = map(peers, function(peer) { + return peer.weight; + }); + this._i = -1; + this._cw = 0; + this._maxS = max.apply(null, weights); + this._gcdS = reduce( + weights, + function(prev, weight) { + return gcd(prev, weight); + }, + 0 + ); + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/abbrev.js b/src/miniprogram_npm/miniprogram-licia/abbrev.js new file mode 100644 index 0000000..bd5735a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/abbrev.js @@ -0,0 +1,28 @@ +var restArgs = require('./restArgs'); +var isSorted = require('./isSorted'); +exports = restArgs(function(names) { + names = names.sort(isSorted.defComparator); + var ret = {}; + var idleMap = {}; + for (var i = 0, len = names.length; i < len; i++) { + var str = names[i]; + var nextStr = names[i + 1] || ''; + if (str === nextStr) continue; + var start = false; + var abbrev = ''; + for (var j = 0, strLen = str.length; j < strLen; j++) { + abbrev += str[j]; + if (!start && (str[j] !== nextStr[j] || j === strLen - 1)) { + start = true; + } + if (!start) { + idleMap[abbrev] = str; + } else if (!ret[abbrev] && !idleMap[abbrev]) { + ret[abbrev] = str; + } + } + } + return ret; +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/after.js b/src/miniprogram_npm/miniprogram-licia/after.js new file mode 100644 index 0000000..6cb4ac3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/after.js @@ -0,0 +1,7 @@ +exports = function(n, fn) { + return function() { + if (--n < 1) return fn.apply(this, arguments); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/allKeys.js b/src/miniprogram_npm/miniprogram-licia/allKeys.js new file mode 100644 index 0000000..15ab6b3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/allKeys.js @@ -0,0 +1,42 @@ +var keys = require('./keys'); +var getProto = require('./getProto'); +var unique = require('./unique'); +var getOwnPropertyNames = Object.getOwnPropertyNames; +var getOwnPropertySymbols = Object.getOwnPropertySymbols; +exports = function(obj) { + var _ref = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : {}, + _ref$prototype = _ref.prototype, + prototype = _ref$prototype === void 0 ? true : _ref$prototype, + _ref$unenumerable = _ref.unenumerable, + unenumerable = _ref$unenumerable === void 0 ? false : _ref$unenumerable, + _ref$symbol = _ref.symbol, + symbol = _ref$symbol === void 0 ? false : _ref$symbol; + var ret = []; + if ((unenumerable || symbol) && getOwnPropertyNames) { + var getKeys = keys; + if (unenumerable && getOwnPropertyNames) getKeys = getOwnPropertyNames; + do { + ret = ret.concat(getKeys(obj)); + if (symbol && getOwnPropertySymbols) { + ret = ret.concat(getOwnPropertySymbols(obj)); + } + } while ( + prototype && + (obj = getProto(obj)) && + obj !== Object.prototype + ); + ret = unique(ret); + } else { + if (prototype) { + for (var key in obj) ret.push(key); + } else { + ret = keys(obj); + } + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/arrToMap.js b/src/miniprogram_npm/miniprogram-licia/arrToMap.js new file mode 100644 index 0000000..f00945b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/arrToMap.js @@ -0,0 +1,14 @@ +var each = require('./each'); +var isUndef = require('./isUndef'); +var isFn = require('./isFn'); +exports = function(arr, val) { + if (isUndef(val)) val = true; + var _isFn = isFn(val); + var ret = {}; + each(arr, function(key) { + ret[key] = _isFn ? val(key) : val; + }); + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/atob.js b/src/miniprogram_npm/miniprogram-licia/atob.js new file mode 100644 index 0000000..2ba684b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/atob.js @@ -0,0 +1,21 @@ +var root = require('./root'); +var isNode = require('./isNode'); +var base64 = require('./base64'); +var map = require('./map'); +if (isNode) { + exports = function(str) { + return new Buffer(str, 'base64').toString('binary'); + }; +} else { + if (root.atob && !false) { + exports = root.atob; + } else { + exports = function(str) { + return map(base64.decode(str), function(c) { + return String.fromCharCode(c); + }).join(''); + }; + } +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/average.js b/src/miniprogram_npm/miniprogram-licia/average.js new file mode 100644 index 0000000..b68943f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/average.js @@ -0,0 +1,9 @@ +exports = function() { + var arr = arguments; + var sum = 0; + var len = arr.length; + for (var i = 0; i < len; i++) sum += arr[i]; + return sum / len; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/base64.js b/src/miniprogram_npm/miniprogram-licia/base64.js new file mode 100644 index 0000000..e40fe7f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/base64.js @@ -0,0 +1,83 @@ +exports = { + encode: function(bytes) { + var ret = []; + var len = bytes.length; + var remain = len % 3; + len = len - remain; + for (var i = 0; i < len; i += 3) { + ret.push( + numToBase64( + (bytes[i] << 16) + (bytes[i + 1] << 8) + bytes[i + 2] + ) + ); + } + len = bytes.length; + var tmp; + if (remain === 1) { + tmp = bytes[len - 1]; + ret.push(code[tmp >> 2]); + ret.push(code[(tmp << 4) & 0x3f]); + ret.push('=='); + } else if (remain === 2) { + tmp = (bytes[len - 2] << 8) + bytes[len - 1]; + ret.push(code[tmp >> 10]); + ret.push(code[(tmp >> 4) & 0x3f]); + ret.push(code[(tmp << 2) & 0x3f]); + ret.push('='); + } + return ret.join(''); + }, + decode: function(str) { + var len = str.length, + remain = 0; + if (str[len - 2] === '=') remain = 2; + else if (str[len - 1] === '=') remain = 1; + var ret = new Array((len * 3) / 4 - remain); + len = remain > 0 ? len - 4 : len; + var i, j; + for (i = 0, j = 0; i < len; i += 4) { + var num = base64ToNum(str[i], str[i + 1], str[i + 2], str[i + 3]); + ret[j++] = (num >> 16) & 0xff; + ret[j++] = (num >> 8) & 0xff; + ret[j++] = num & 0xff; + } + var tmp; + if (remain === 2) { + tmp = + (codeMap[str.charCodeAt(i)] << 2) | + (codeMap[str.charCodeAt(i + 1)] >> 4); + ret[j++] = tmp & 0xff; + } else if (remain === 1) { + tmp = + (codeMap[str.charCodeAt(i)] << 10) | + (codeMap[str.charCodeAt(i + 1)] << 4) | + (codeMap[str.charCodeAt(i + 2)] >> 2); + ret[j++] = (tmp >> 8) & 0xff; + ret[j++] = tmp & 0xff; + } + return ret; + } +}; +var codeMap = []; +var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; +for (var i = 0, len = code.length; i < len; i++) { + codeMap[code.charCodeAt(i)] = i; +} +function numToBase64(num) { + return ( + code[(num >> 18) & 0x3f] + + code[(num >> 12) & 0x3f] + + code[(num >> 6) & 0x3f] + + code[num & 0x3f] + ); +} +function base64ToNum(str1, str2, str3, str4) { + return ( + (codeMap[str1.charCodeAt(0)] << 18) | + (codeMap[str2.charCodeAt(0)] << 12) | + (codeMap[str3.charCodeAt(0)] << 6) | + codeMap[str4.charCodeAt(0)] + ); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/before.js b/src/miniprogram_npm/miniprogram-licia/before.js new file mode 100644 index 0000000..5c25de3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/before.js @@ -0,0 +1,10 @@ +exports = function(n, fn) { + var memo; + return function() { + if (--n > 0) memo = fn.apply(this, arguments); + if (n <= 1) fn = null; + return memo; + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/binarySearch.js b/src/miniprogram_npm/miniprogram-licia/binarySearch.js new file mode 100644 index 0000000..895f2cb --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/binarySearch.js @@ -0,0 +1,24 @@ +var isSorted = require('./isSorted'); +exports = function(arr, val) { + var cmp = + arguments.length > 2 && arguments[2] !== undefined + ? arguments[2] + : isSorted.defComparator; + var startIdx = 0; + var endIdx = arr.length - 1; + while (startIdx <= endIdx) { + var middleIdx = startIdx + Math.floor((endIdx - startIdx) / 2); + var middleVal = arr[middleIdx]; + if (cmp(middleVal, val) === 0) { + return middleIdx; + } + if (cmp(middleVal, val) < 0) { + startIdx = middleIdx + 1; + } else { + endIdx = middleIdx - 1; + } + } + return -1; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/bind.js b/src/miniprogram_npm/miniprogram-licia/bind.js new file mode 100644 index 0000000..64a793e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/bind.js @@ -0,0 +1,8 @@ +var restArgs = require('./restArgs'); +exports = restArgs(function(fn, ctx, args) { + return restArgs(function(callArgs) { + return fn.apply(ctx, args.concat(callArgs)); + }); +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/btoa.js b/src/miniprogram_npm/miniprogram-licia/btoa.js new file mode 100644 index 0000000..0a0470c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/btoa.js @@ -0,0 +1,23 @@ +var root = require('./root'); +var isNode = require('./isNode'); +var base64 = require('./base64'); +var map = require('./map'); +if (isNode) { + exports = function(str) { + return new Buffer(str, 'binary').toString('base64'); + }; +} else { + if (root.btoa && !false) { + exports = root.btoa; + } else { + exports = function(str) { + return base64.encode( + map(str, function(c) { + return c.charCodeAt(0); + }) + ); + }; + } +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/bubbleSort.js b/src/miniprogram_npm/miniprogram-licia/bubbleSort.js new file mode 100644 index 0000000..29fbab8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/bubbleSort.js @@ -0,0 +1,18 @@ +var swap = require('./swap'); +var isSorted = require('./isSorted'); +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : isSorted.defComparator; + for (var i = 0, len = arr.length; i < len; i++) { + for (var j = i; j > 0; j--) { + if (cmp(arr[j], arr[j - 1]) < 0) { + swap(arr, j, j - 1); + } + } + } + return arr; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/bytesToStr.js b/src/miniprogram_npm/miniprogram-licia/bytesToStr.js new file mode 100644 index 0000000..820b611 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/bytesToStr.js @@ -0,0 +1,22 @@ +var utf8 = require('./utf8'); +var hex = require('./hex'); +var base64 = require('./base64'); +exports = function(bytes) { + var encoding = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : 'utf8'; + if (encoding === 'hex') return hex.encode(bytes); + if (encoding === 'base64') return base64.encode(bytes); + var str = []; + for (var i = 0, len = bytes.length; i < len; i++) { + str.push(String.fromCharCode(bytes[i])); + } + str = str.join(''); + if (encoding === 'utf8') { + str = utf8.decode(str); + } + return str; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/bytesToWords.js b/src/miniprogram_npm/miniprogram-licia/bytesToWords.js new file mode 100644 index 0000000..157ec11 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/bytesToWords.js @@ -0,0 +1,9 @@ +exports = function(bytes) { + var words = []; + for (var i = 0, len = bytes.length; i < len; i++) { + words[i >>> 2] |= bytes[i] << (24 - (i % 4) * 8); + } + return words; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/callbackify.js b/src/miniprogram_npm/miniprogram-licia/callbackify.js new file mode 100644 index 0000000..6124bc5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/callbackify.js @@ -0,0 +1,17 @@ +var restArgs = require('./restArgs'); +exports = function(fn) { + return restArgs(function(args) { + var cb = args.pop(); + fn.apply(this, args).then( + function(value) { + cb(null, value); + }, + function(err) { + if (err === null) err = new Error(); + cb(err); + } + ); + }); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/camelCase.js b/src/miniprogram_npm/miniprogram-licia/camelCase.js new file mode 100644 index 0000000..2f35235 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/camelCase.js @@ -0,0 +1,16 @@ +var splitCase = require('./splitCase'); +exports = function(str) { + var arr = splitCase(str); + var ret = arr[0]; + arr.shift(); + arr.forEach(capitalize, arr); + ret += arr.join(''); + return ret; +}; +function capitalize(val, idx) { + this[idx] = val.replace(/\w/, function(match) { + return match.toUpperCase(); + }); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/capitalize.js b/src/miniprogram_npm/miniprogram-licia/capitalize.js new file mode 100644 index 0000000..9d73fba --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/capitalize.js @@ -0,0 +1,5 @@ +exports = function(str) { + return str.charAt(0).toUpperCase() + str.substring(1).toLowerCase(); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/castPath.js b/src/miniprogram_npm/miniprogram-licia/castPath.js new file mode 100644 index 0000000..068affa --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/castPath.js @@ -0,0 +1,16 @@ +var has = require('./has'); +var isArr = require('./isArr'); +exports = function(str, obj) { + if (isArr(str)) return str; + if (obj && has(obj, str)) return [str]; + var ret = []; + str.replace(regPropName, function(match, number, quote, str) { + ret.push(quote ? str.replace(regEscapeChar, '$1') : number || match); + }); + return ret; +}; + +var regPropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; +var regEscapeChar = /\\(\\)?/g; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/centerAlign.js b/src/miniprogram_npm/miniprogram-licia/centerAlign.js new file mode 100644 index 0000000..0de3528 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/centerAlign.js @@ -0,0 +1,21 @@ +var longest = require('./longest'); +var isArr = require('./isArr'); +var isUndef = require('./isUndef'); +var map = require('./map'); +var lpad = require('./lpad'); +exports = function(str, width) { + var ret = str; + if (!isArr(ret)) { + ret = ret.split(regLineBreak); + } + if (isUndef(width)) width = longest(str); + ret = map(ret, function(str) { + var len = str.length; + return lpad(str, floor((width - len) / 2) + len); + }); + return ret.join('\n'); +}; +var regLineBreak = /\n/g; +var floor = Math.floor; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/char.js b/src/miniprogram_npm/miniprogram-licia/char.js new file mode 100644 index 0000000..4f84fcc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/char.js @@ -0,0 +1,5 @@ +exports = function(num) { + return String.fromCodePoint(num); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/chunk.js b/src/miniprogram_npm/miniprogram-licia/chunk.js new file mode 100644 index 0000000..5cedd72 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/chunk.js @@ -0,0 +1,12 @@ +exports = function(arr, size) { + var ret = []; + size = size || 1; + for (var i = 0, len = Math.ceil(arr.length / size); i < len; i++) { + var start = i * size; + var end = start + size; + ret.push(arr.slice(start, end)); + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/clamp.js b/src/miniprogram_npm/miniprogram-licia/clamp.js new file mode 100644 index 0000000..56a4b10 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/clamp.js @@ -0,0 +1,12 @@ +var isUndef = require('./isUndef'); +exports = function(n, lower, upper) { + if (isUndef(upper)) { + upper = lower; + lower = undefined; + } + if (!isUndef(lower) && n < lower) return lower; + if (n > upper) return upper; + return n; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/className.js b/src/miniprogram_npm/miniprogram-licia/className.js new file mode 100644 index 0000000..3cfd3d5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/className.js @@ -0,0 +1,20 @@ +var each = require('./each'); +var isStr = require('./isStr'); +var isNum = require('./isNum'); +var isArr = require('./isArr'); +var isObj = require('./isObj'); +exports = function() { + var ret = []; + each(arguments, function(arg) { + if (!arg) return; + if (isStr(arg) || isNum(arg)) return ret.push(arg); + if (isArr(arg)) return ret.push(exports.apply(null, arg)); + if (!isObj(arg)) return; + each(arg, function(val, key) { + if (val) ret.push(key); + }); + }); + return ret.join(' '); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/clone.js b/src/miniprogram_npm/miniprogram-licia/clone.js new file mode 100644 index 0000000..3b73e6a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/clone.js @@ -0,0 +1,9 @@ +var isObj = require('./isObj'); +var isArr = require('./isArr'); +var extend = require('./extend'); +exports = function(obj) { + if (!isObj(obj)) return obj; + return isArr(obj) ? obj.slice() : extend({}, obj); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/cloneDeep.js b/src/miniprogram_npm/miniprogram-licia/cloneDeep.js new file mode 100644 index 0000000..5babdae --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/cloneDeep.js @@ -0,0 +1,19 @@ +var isObj = require('./isObj'); +var isFn = require('./isFn'); +var isArr = require('./isArr'); +var mapObj = require('./mapObj'); +exports = function(obj) { + if (isArr(obj)) { + return obj.map(function(val) { + return exports(val); + }); + } + if (isObj(obj) && !isFn(obj)) { + return mapObj(obj, function(val) { + return exports(val); + }); + } + return obj; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/cmpVersion.js b/src/miniprogram_npm/miniprogram-licia/cmpVersion.js new file mode 100644 index 0000000..755df90 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/cmpVersion.js @@ -0,0 +1,16 @@ +var toInt = require('./toInt'); +var max = require('./max'); +exports = function(v1, v2) { + v1 = v1.split('.'); + v2 = v2.split('.'); + var len = max(v1.length, v2.length); + for (var i = 0; i < len; i++) { + var num1 = toInt(v1[i]); + var num2 = toInt(v2[i]); + if (num1 > num2) return 1; + if (num1 < num2) return -1; + } + return 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/combine.js b/src/miniprogram_npm/miniprogram-licia/combine.js new file mode 100644 index 0000000..337493b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/combine.js @@ -0,0 +1,9 @@ +exports = function(keys, values) { + var ret = {}; + for (var i = 0, len = keys.length; i < len; i++) { + ret[keys[i]] = values[i]; + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/compact.js b/src/miniprogram_npm/miniprogram-licia/compact.js new file mode 100644 index 0000000..5191a5f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/compact.js @@ -0,0 +1,8 @@ +var filter = require('./filter'); +exports = function(arr) { + return filter(arr, function(val) { + return !!val; + }); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/compose.js b/src/miniprogram_npm/miniprogram-licia/compose.js new file mode 100644 index 0000000..c3537b0 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/compose.js @@ -0,0 +1,11 @@ +var restArgs = require('./restArgs'); +exports = restArgs(function(fnList) { + return function() { + var i = fnList.length - 1; + var result = fnList[i].apply(this, arguments); + while (i--) result = fnList[i].call(this, result); + return result; + }; +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/concat.js b/src/miniprogram_npm/miniprogram-licia/concat.js new file mode 100644 index 0000000..11281a5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/concat.js @@ -0,0 +1,11 @@ +var toArr = require('./toArr'); +exports = function() { + var args = toArr(arguments); + var ret = []; + for (var i = 0, len = args.length; i < len; i++) { + ret = ret.concat(toArr(args[i])); + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/contain.js b/src/miniprogram_npm/miniprogram-licia/contain.js new file mode 100644 index 0000000..10ca0f7 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/contain.js @@ -0,0 +1,11 @@ +var idxOf = require('./idxOf'); +var isStr = require('./isStr'); +var isArrLike = require('./isArrLike'); +var values = require('./values'); +exports = function(arr, val) { + if (isStr(arr)) return arr.indexOf(val) > -1; + if (!isArrLike(arr)) arr = values(arr); + return idxOf(arr, val) >= 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/convertBase.js b/src/miniprogram_npm/miniprogram-licia/convertBase.js new file mode 100644 index 0000000..65c0a3d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/convertBase.js @@ -0,0 +1,5 @@ +exports = function(num, from, to) { + return parseInt(num, from).toString(to); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/convertBin.js b/src/miniprogram_npm/miniprogram-licia/convertBin.js new file mode 100644 index 0000000..99d2734 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/convertBin.js @@ -0,0 +1,60 @@ +var isStr = require('./isStr'); +var base64 = require('./base64'); +var isArrBuffer = require('./isArrBuffer'); +var isArr = require('./isArr'); +var isBuffer = require('./isBuffer'); +var type = require('./type'); +var lowerCase = require('./lowerCase'); +exports = function(bin, t) { + var result; + t = lowerCase(t); + if (isStr(bin)) { + result = new Uint8Array(base64.decode(bin)); + } else if (isArrBuffer(bin)) { + bin = bin.slice(0); + result = new Uint8Array(bin); + } else if (isArr(bin)) { + result = new Uint8Array(bin); + } else if (type(bin) === 'uint8array') { + result = bin.slice(0); + } else if (isBuffer(bin)) { + result = new Uint8Array(bin.length); + for (var i = 0; i < bin.length; i++) { + result[i] = bin[i]; + } + } + if (result) { + switch (t) { + case 'base64': + result = base64.encode(result); + break; + case 'arraybuffer': + result = result.buffer; + break; + case 'array': + result = [].slice.call(result); + break; + case 'buffer': + result = Buffer.from(result); + break; + case 'blob': + result = new Blob([result.buffer]); + break; + } + } + return result; +}; +exports.blobToArrBuffer = function(blob) { + return new Promise(function(resolve, reject) { + var fileReader = new FileReader(); + fileReader.onload = function(e) { + resolve(e.target.result); + }; + fileReader.onerror = function(err) { + reject(err); + }; + fileReader.readAsArrayBuffer(blob); + }); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/crc1.js b/src/miniprogram_npm/miniprogram-licia/crc1.js new file mode 100644 index 0000000..919a884 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/crc1.js @@ -0,0 +1,19 @@ +var isStr = require('./isStr'); +var strToBytes = require('./strToBytes'); + +exports = function(input, previous) { + return exports.signed(input, previous) >>> 0; +}; +exports.signed = function(input, previous) { + if (isStr(input)) input = strToBytes(input); + var crc = ~~previous; + var accum = 0; + for (var i = 0, len = input.length; i < len; i++) { + var byte = input[i]; + accum += byte; + } + crc += accum % 256; + return crc % 256; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/crc16.js b/src/miniprogram_npm/miniprogram-licia/crc16.js new file mode 100644 index 0000000..f6a33d1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/crc16.js @@ -0,0 +1,276 @@ +var isStr = require('./isStr'); +var strToBytes = require('./strToBytes'); + +var TABLE = [ + 0x0000, + 0xc0c1, + 0xc181, + 0x0140, + 0xc301, + 0x03c0, + 0x0280, + 0xc241, + 0xc601, + 0x06c0, + 0x0780, + 0xc741, + 0x0500, + 0xc5c1, + 0xc481, + 0x0440, + 0xcc01, + 0x0cc0, + 0x0d80, + 0xcd41, + 0x0f00, + 0xcfc1, + 0xce81, + 0x0e40, + 0x0a00, + 0xcac1, + 0xcb81, + 0x0b40, + 0xc901, + 0x09c0, + 0x0880, + 0xc841, + 0xd801, + 0x18c0, + 0x1980, + 0xd941, + 0x1b00, + 0xdbc1, + 0xda81, + 0x1a40, + 0x1e00, + 0xdec1, + 0xdf81, + 0x1f40, + 0xdd01, + 0x1dc0, + 0x1c80, + 0xdc41, + 0x1400, + 0xd4c1, + 0xd581, + 0x1540, + 0xd701, + 0x17c0, + 0x1680, + 0xd641, + 0xd201, + 0x12c0, + 0x1380, + 0xd341, + 0x1100, + 0xd1c1, + 0xd081, + 0x1040, + 0xf001, + 0x30c0, + 0x3180, + 0xf141, + 0x3300, + 0xf3c1, + 0xf281, + 0x3240, + 0x3600, + 0xf6c1, + 0xf781, + 0x3740, + 0xf501, + 0x35c0, + 0x3480, + 0xf441, + 0x3c00, + 0xfcc1, + 0xfd81, + 0x3d40, + 0xff01, + 0x3fc0, + 0x3e80, + 0xfe41, + 0xfa01, + 0x3ac0, + 0x3b80, + 0xfb41, + 0x3900, + 0xf9c1, + 0xf881, + 0x3840, + 0x2800, + 0xe8c1, + 0xe981, + 0x2940, + 0xeb01, + 0x2bc0, + 0x2a80, + 0xea41, + 0xee01, + 0x2ec0, + 0x2f80, + 0xef41, + 0x2d00, + 0xedc1, + 0xec81, + 0x2c40, + 0xe401, + 0x24c0, + 0x2580, + 0xe541, + 0x2700, + 0xe7c1, + 0xe681, + 0x2640, + 0x2200, + 0xe2c1, + 0xe381, + 0x2340, + 0xe101, + 0x21c0, + 0x2080, + 0xe041, + 0xa001, + 0x60c0, + 0x6180, + 0xa141, + 0x6300, + 0xa3c1, + 0xa281, + 0x6240, + 0x6600, + 0xa6c1, + 0xa781, + 0x6740, + 0xa501, + 0x65c0, + 0x6480, + 0xa441, + 0x6c00, + 0xacc1, + 0xad81, + 0x6d40, + 0xaf01, + 0x6fc0, + 0x6e80, + 0xae41, + 0xaa01, + 0x6ac0, + 0x6b80, + 0xab41, + 0x6900, + 0xa9c1, + 0xa881, + 0x6840, + 0x7800, + 0xb8c1, + 0xb981, + 0x7940, + 0xbb01, + 0x7bc0, + 0x7a80, + 0xba41, + 0xbe01, + 0x7ec0, + 0x7f80, + 0xbf41, + 0x7d00, + 0xbdc1, + 0xbc81, + 0x7c40, + 0xb401, + 0x74c0, + 0x7580, + 0xb541, + 0x7700, + 0xb7c1, + 0xb681, + 0x7640, + 0x7200, + 0xb2c1, + 0xb381, + 0x7340, + 0xb101, + 0x71c0, + 0x7080, + 0xb041, + 0x5000, + 0x90c1, + 0x9181, + 0x5140, + 0x9301, + 0x53c0, + 0x5280, + 0x9241, + 0x9601, + 0x56c0, + 0x5780, + 0x9741, + 0x5500, + 0x95c1, + 0x9481, + 0x5440, + 0x9c01, + 0x5cc0, + 0x5d80, + 0x9d41, + 0x5f00, + 0x9fc1, + 0x9e81, + 0x5e40, + 0x5a00, + 0x9ac1, + 0x9b81, + 0x5b40, + 0x9901, + 0x59c0, + 0x5880, + 0x9841, + 0x8801, + 0x48c0, + 0x4980, + 0x8941, + 0x4b00, + 0x8bc1, + 0x8a81, + 0x4a40, + 0x4e00, + 0x8ec1, + 0x8f81, + 0x4f40, + 0x8d01, + 0x4dc0, + 0x4c80, + 0x8c41, + 0x4400, + 0x84c1, + 0x8581, + 0x4540, + 0x8701, + 0x47c0, + 0x4680, + 0x8641, + 0x8201, + 0x42c0, + 0x4380, + 0x8341, + 0x4100, + 0x81c1, + 0x8081, + 0x4040 +]; +if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); +exports = function(input, previous) { + return exports.signed(input, previous) >>> 0; +}; +exports.signed = function(input, previous) { + if (isStr(input)) input = strToBytes(input); + var crc = ~~previous; + for (var i = 0, len = input.length; i < len; i++) { + var byte = input[i]; + crc = (TABLE[(crc ^ byte) & 0xff] ^ (crc >> 8)) & 0xffff; + } + return crc; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/crc32.js b/src/miniprogram_npm/miniprogram-licia/crc32.js new file mode 100644 index 0000000..06f0d2a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/crc32.js @@ -0,0 +1,29 @@ +var isStr = require('./isStr'); +var strToBytes = require('./strToBytes'); +var TABLE = []; +for (var n = 0; n < 256; n++) { + var c = n; + for (var k = 0; k < 8; k++) { + if (c & 1) { + c = 0xedb88320 ^ (c >>> 1); + } else { + c = c >>> 1; + } + } + TABLE[n] = c >>> 0; +} +if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); +exports = function(input, previous) { + return exports.signed(input, previous) >>> 0; +}; +exports.signed = function(input, previous) { + if (isStr(input)) input = strToBytes(input); + var crc = previous === 0 ? 0 : ~~previous ^ -1; + for (var i = 0, len = input.length; i < len; i++) { + var byte = input[i]; + crc = TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8); + } + return crc ^ -1; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/crc8.js b/src/miniprogram_npm/miniprogram-licia/crc8.js new file mode 100644 index 0000000..fbf930f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/crc8.js @@ -0,0 +1,276 @@ +var isStr = require('./isStr'); +var strToBytes = require('./strToBytes'); + +var TABLE = [ + 0x00, + 0x07, + 0x0e, + 0x09, + 0x1c, + 0x1b, + 0x12, + 0x15, + 0x38, + 0x3f, + 0x36, + 0x31, + 0x24, + 0x23, + 0x2a, + 0x2d, + 0x70, + 0x77, + 0x7e, + 0x79, + 0x6c, + 0x6b, + 0x62, + 0x65, + 0x48, + 0x4f, + 0x46, + 0x41, + 0x54, + 0x53, + 0x5a, + 0x5d, + 0xe0, + 0xe7, + 0xee, + 0xe9, + 0xfc, + 0xfb, + 0xf2, + 0xf5, + 0xd8, + 0xdf, + 0xd6, + 0xd1, + 0xc4, + 0xc3, + 0xca, + 0xcd, + 0x90, + 0x97, + 0x9e, + 0x99, + 0x8c, + 0x8b, + 0x82, + 0x85, + 0xa8, + 0xaf, + 0xa6, + 0xa1, + 0xb4, + 0xb3, + 0xba, + 0xbd, + 0xc7, + 0xc0, + 0xc9, + 0xce, + 0xdb, + 0xdc, + 0xd5, + 0xd2, + 0xff, + 0xf8, + 0xf1, + 0xf6, + 0xe3, + 0xe4, + 0xed, + 0xea, + 0xb7, + 0xb0, + 0xb9, + 0xbe, + 0xab, + 0xac, + 0xa5, + 0xa2, + 0x8f, + 0x88, + 0x81, + 0x86, + 0x93, + 0x94, + 0x9d, + 0x9a, + 0x27, + 0x20, + 0x29, + 0x2e, + 0x3b, + 0x3c, + 0x35, + 0x32, + 0x1f, + 0x18, + 0x11, + 0x16, + 0x03, + 0x04, + 0x0d, + 0x0a, + 0x57, + 0x50, + 0x59, + 0x5e, + 0x4b, + 0x4c, + 0x45, + 0x42, + 0x6f, + 0x68, + 0x61, + 0x66, + 0x73, + 0x74, + 0x7d, + 0x7a, + 0x89, + 0x8e, + 0x87, + 0x80, + 0x95, + 0x92, + 0x9b, + 0x9c, + 0xb1, + 0xb6, + 0xbf, + 0xb8, + 0xad, + 0xaa, + 0xa3, + 0xa4, + 0xf9, + 0xfe, + 0xf7, + 0xf0, + 0xe5, + 0xe2, + 0xeb, + 0xec, + 0xc1, + 0xc6, + 0xcf, + 0xc8, + 0xdd, + 0xda, + 0xd3, + 0xd4, + 0x69, + 0x6e, + 0x67, + 0x60, + 0x75, + 0x72, + 0x7b, + 0x7c, + 0x51, + 0x56, + 0x5f, + 0x58, + 0x4d, + 0x4a, + 0x43, + 0x44, + 0x19, + 0x1e, + 0x17, + 0x10, + 0x05, + 0x02, + 0x0b, + 0x0c, + 0x21, + 0x26, + 0x2f, + 0x28, + 0x3d, + 0x3a, + 0x33, + 0x34, + 0x4e, + 0x49, + 0x40, + 0x47, + 0x52, + 0x55, + 0x5c, + 0x5b, + 0x76, + 0x71, + 0x78, + 0x7f, + 0x6a, + 0x6d, + 0x64, + 0x63, + 0x3e, + 0x39, + 0x30, + 0x37, + 0x22, + 0x25, + 0x2c, + 0x2b, + 0x06, + 0x01, + 0x08, + 0x0f, + 0x1a, + 0x1d, + 0x14, + 0x13, + 0xae, + 0xa9, + 0xa0, + 0xa7, + 0xb2, + 0xb5, + 0xbc, + 0xbb, + 0x96, + 0x91, + 0x98, + 0x9f, + 0x8a, + 0x8d, + 0x84, + 0x83, + 0xde, + 0xd9, + 0xd0, + 0xd7, + 0xc2, + 0xc5, + 0xcc, + 0xcb, + 0xe6, + 0xe1, + 0xe8, + 0xef, + 0xfa, + 0xfd, + 0xf4, + 0xf3 +]; +if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); +exports = function(input, previous) { + return exports.signed(input, previous) >>> 0; +}; +exports.signed = function(input, previous) { + if (isStr(input)) input = strToBytes(input); + var crc = ~~previous; + for (var i = 0, len = input.length; i < len; i++) { + var byte = input[i]; + crc = TABLE[(crc ^ byte) & 0xff] & 0xff; + } + return crc; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/create.js b/src/miniprogram_npm/miniprogram-licia/create.js new file mode 100644 index 0000000..a5302e5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/create.js @@ -0,0 +1,11 @@ +var isObj = require('./isObj'); +exports = function(proto) { + if (!isObj(proto)) return {}; + if (objCreate && !false) return objCreate(proto); + function noop() {} + noop.prototype = proto; + return new noop(); +}; +var objCreate = Object.create; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/createAssigner.js b/src/miniprogram_npm/miniprogram-licia/createAssigner.js new file mode 100644 index 0000000..2ce8691 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/createAssigner.js @@ -0,0 +1,16 @@ +var isUndef = require('./isUndef'); +var each = require('./each'); +exports = function(keysFn, defaults) { + return function(obj) { + each(arguments, function(src, idx) { + if (idx === 0) return; + var keys = keysFn(src); + each(keys, function(key) { + if (!defaults || isUndef(obj[key])) obj[key] = src[key]; + }); + }); + return obj; + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/css.js b/src/miniprogram_npm/miniprogram-licia/css.js new file mode 100644 index 0000000..ac7ac3f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/css.js @@ -0,0 +1,329 @@ +var Class = require('./Class'); +var trim = require('./trim'); +var repeat = require('./repeat'); +var defaults = require('./defaults'); +var camelCase = require('./camelCase'); + +exports = { + parse: function(css) { + return new Parser(css).parse(); + }, + stringify: function(stylesheet, options) { + return new Compiler(stylesheet, options).compile(); + } +}; +var regComments = /(\/\*[\s\S]*?\*\/)/gi; +var regOpen = /^{\s*/; +var regClose = /^}/; +var regWhitespace = /^\s*/; +var regProperty = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/; +var regValue = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/; +var regSelector = /^([^{]+)/; +var regSemicolon = /^[;\s]*/; +var regColon = /^:\s*/; +var regMedia = /^@media *([^{]+)/; +var regKeyframes = /^@([-\w]+)?keyframes\s*/; +var regFontFace = /^@font-face\s*/; +var regSupports = /^@supports *([^{]+)/; +var regIdentifier = /^([-\w]+)\s*/; +var regKeyframeSelector = /^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/; +var regComma = /^,\s*/; +var Parser = Class({ + initialize: function Parser(css) { + this.input = stripCmt(css); + this.open = this._createMatcher(regOpen); + this.close = this._createMatcher(regClose); + this.whitespace = this._createMatcher(regWhitespace); + this.atImport = this._createAtRule('import'); + this.atCharset = this._createAtRule('charset'); + this.atNamespace = this._createAtRule('namespace'); + }, + parse: function() { + return this.stylesheet(); + }, + stylesheet: function() { + return { + type: 'stylesheet', + rules: this.rules() + }; + }, + rules: function() { + var rule; + var rules = []; + this.whitespace(); + while ( + this.input.length && + this.input[0] !== '}' && + (rule = this.atRule() || this.rule()) + ) { + rules.push(rule); + this.whitespace(); + } + return rules; + }, + atRule: function() { + if (this.input[0] !== '@') return; + return ( + this.atKeyframes() || + this.atMedia() || + this.atSupports() || + this.atImport() || + this.atCharset() || + this.atNamespace() || + this.atFontFace() + ); + }, + atKeyframes: function() { + var matched = this.match(regKeyframes); + if (!matched) return; + var vendor = matched[1] || ''; + matched = this.match(regIdentifier); + if (!matched) throw Error('@keyframes missing name'); + var name = matched[1]; + if (!this.open()) throw Error("@keyframes missing '{'"); + var keyframes = []; + var keyframe; + while ((keyframe = this.keyframe())) { + keyframes.push(keyframe); + } + if (!this.close()) throw Error("@keyframes missing '}'"); + return { + type: 'keyframes', + name: name, + vendor: vendor, + keyframes: keyframes + }; + }, + keyframe: function() { + var selector = []; + var matched; + while ((matched = this.match(regKeyframeSelector))) { + selector.push(matched[1]); + this.match(regComma); + } + if (!selector.length) return; + this.whitespace(); + return { + type: 'keyframe', + selector: selector.join(', '), + declarations: this.declarations() + }; + }, + atSupports: function() { + var matched = this.match(regSupports); + if (!matched) return; + var supports = trim(matched[1]); + if (!this.open()) throw Error("@supports missing '{'"); + var rules = this.rules(); + if (!this.close()) throw Error("@supports missing '}'"); + return { + type: 'supports', + supports: supports, + rules: rules + }; + }, + atFontFace: function() { + var matched = this.match(regFontFace); + if (!matched) return; + if (!this.open()) throw Error("@font-face missing '{'"); + var declaration; + var declarations = []; + while ((declaration = this.declaration())) { + declarations.push(declaration); + } + if (!this.close()) throw Error("@font-face missing '}'"); + return { + type: 'font-face', + declarations: declarations + }; + }, + atMedia: function() { + var matched = this.match(regMedia); + if (!matched) return; + var media = trim(matched[1]); + if (!this.open()) throw Error("@media missing '{'"); + this.whitespace(); + var rules = this.rules(); + if (!this.close()) throw Error("@media missing '}'"); + return { + type: 'media', + media: media, + rules: rules + }; + }, + rule: function() { + var selector = this.selector(); + if (!selector) throw Error('missing selector'); + return { + type: 'rule', + selector: selector, + declarations: this.declarations() + }; + }, + declarations: function() { + var declarations = []; + if (!this.open()) throw Error("missing '{'"); + this.whitespace(); + var declaration; + while ((declaration = this.declaration())) { + declarations.push(declaration); + } + if (!this.close()) throw Error("missing '}'"); + this.whitespace(); + return declarations; + }, + declaration: function() { + var property = this.match(regProperty); + if (!property) return; + property = trim(property[0]); + if (!this.match(regColon)) throw Error("property missing ':'"); + var value = this.match(regValue); + this.match(regSemicolon); + this.whitespace(); + return { + type: 'declaration', + property: property, + value: value ? trim(value[0]) : '' + }; + }, + selector: function() { + var matched = this.match(regSelector); + if (!matched) return; + return trim(matched[0]); + }, + match: function(reg) { + var matched = reg.exec(this.input); + if (!matched) return; + this.input = this.input.slice(matched[0].length); + return matched; + }, + _createMatcher: function(reg) { + var _this = this; + return function() { + return _this.match(reg); + }; + }, + _createAtRule: function(name) { + var reg = new RegExp('^@' + name + '\\s*([^;]+);'); + return function() { + var matched = this.match(reg); + if (!matched) return; + var ret = { + type: name + }; + ret[name] = trim(matched[1]); + return ret; + }; + } +}); +var Compiler = Class({ + initialize: function Compiler(input) { + var options = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : {}; + defaults(options, { + indent: ' ' + }); + this.input = input; + this.indentLevel = 0; + this.indentation = options.indent; + }, + compile: function() { + return this.stylesheet(this.input); + }, + stylesheet: function(node) { + return this.mapVisit(node.rules, '\n\n'); + }, + media: function(node) { + return ( + '@media ' + + node.media + + ' {\n' + + this.indent(1) + + this.mapVisit(node.rules, '\n\n') + + this.indent(-1) + + '\n}' + ); + }, + keyframes: function(node) { + return ( + '@'.concat(node.vendor, 'keyframes ') + + node.name + + ' {\n' + + this.indent(1) + + this.mapVisit(node.keyframes, '\n') + + this.indent(-1) + + '\n}' + ); + }, + supports: function(node) { + return ( + '@supports ' + + node.supports + + ' {\n' + + this.indent(1) + + this.mapVisit(node.rules, '\n\n') + + this.indent(-1) + + '\n}' + ); + }, + keyframe: function(node) { + return this.rule(node); + }, + mapVisit: function(nodes, delimiter) { + var str = ''; + for (var i = 0, len = nodes.length; i < len; i++) { + var node = nodes[i]; + str += this[camelCase(node.type)](node); + if (delimiter && i < len - 1) str += delimiter; + } + return str; + }, + fontFace: function(node) { + return ( + '@font-face {\n' + + this.indent(1) + + this.mapVisit(node.declarations, '\n') + + this.indent(-1) + + '\n}' + ); + }, + rule: function(node) { + return ( + this.indent() + + node.selector + + ' {\n' + + this.indent(1) + + this.mapVisit(node.declarations, '\n') + + this.indent(-1) + + '\n' + + this.indent() + + '}' + ); + }, + declaration: function(node) { + return this.indent() + node.property + ': ' + node.value + ';'; + }, + import: function(node) { + return '@import '.concat(node.import, ';'); + }, + charset: function(node) { + return '@charset '.concat(node.charset, ';'); + }, + namespace: function(node) { + return '@namespace '.concat(node.namespace, ';'); + }, + indent: function(level) { + if (level) { + this.indentLevel += level; + return ''; + } + return repeat(this.indentation, this.indentLevel); + } +}); +var stripCmt = function(str) { + return str.replace(regComments, ''); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/cssPriority.js b/src/miniprogram_npm/miniprogram-licia/cssPriority.js new file mode 100644 index 0000000..37f8f39 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/cssPriority.js @@ -0,0 +1,63 @@ +var selector = require('./selector'); +var each = require('./each'); +var startWith = require('./startWith'); +var contain = require('./contain'); +var cmpVersion = require('./cmpVersion'); + +exports = function(sel) { + var _ref = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : {}, + _ref$important = _ref.important, + important = _ref$important === void 0 ? false : _ref$important, + _ref$inlineStyle = _ref.inlineStyle, + inlineStyle = _ref$inlineStyle === void 0 ? false : _ref$inlineStyle, + _ref$position = _ref.position, + position = _ref$position === void 0 ? 0 : _ref$position; + var ret = [0, 0, 0, 0, 0, position]; + if (important) ret[0] = 1; + if (inlineStyle) ret[1] = 1; + var group = selector.parse(sel)[0]; + each(group, function(_ref2) { + var type = _ref2.type, + value = _ref2.value; + switch (type) { + case 'id': + ret[2]++; + break; + case 'class': + case 'attribute': + ret[3]++; + break; + case 'pseudo': + if (contain(PSEUDO_ELEMS, value.replace(/:/g, ''))) { + ret[4]++; + } else if (!startWith(value, '::')) { + ret[3]++; + } + break; + case 'tag': + if (value !== '*') { + ret[4]++; + } + break; + } + }); + return ret; +}; +var PSEUDO_ELEMS = [ + 'first-letter', + 'last-letter', + 'first-line', + 'last-line', + 'first-child', + 'last-child', + 'before', + 'after' +]; +exports.compare = function(p1, p2) { + return cmpVersion(p1.join('.'), p2.join('.')); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/curry.js b/src/miniprogram_npm/miniprogram-licia/curry.js new file mode 100644 index 0000000..9d4fd00 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/curry.js @@ -0,0 +1,15 @@ +var toArr = require('./toArr'); +exports = function(fn) { + var len = fn.length; + return function curriedFn() { + var args = toArr(arguments); + if (args.length < len) { + return function() { + return curriedFn.apply(null, args.concat(toArr(arguments))); + }; + } + return fn.apply(null, args); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/dataUrl.js b/src/miniprogram_npm/miniprogram-licia/dataUrl.js new file mode 100644 index 0000000..c93e71e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/dataUrl.js @@ -0,0 +1,68 @@ +var isDataUrl = require('./isDataUrl'); +var trim = require('./trim'); +var endWith = require('./endWith'); +var startWith = require('./startWith'); +var contain = require('./contain'); +var decodeUriComponent = require('./decodeUriComponent'); +var defaults = require('./defaults'); +var isStr = require('./isStr'); +var convertBin = require('./convertBin'); +exports = { + parse: function(dataUrl) { + if (!isDataUrl(dataUrl)) { + return null; + } + dataUrl = dataUrl.slice('data:'.length); + var commaIdx = dataUrl.indexOf(','); + var mime = trim(dataUrl.slice(0, commaIdx)); + var data = trim(dataUrl.slice(commaIdx + 1)); + var base64 = false; + if (endWith(mime, ';base64')) { + base64 = true; + mime = mime.slice(0, -';base64'.length); + } + var charset = ''; + if (contain(mime, 'charset=')) { + charset = mime.split('charset=')[1]; + mime = mime.split(';')[0]; + } + if (!mime) { + mime = 'text/plain'; + } + if (!base64 && startWith(mime, 'text/') && contain(data, '%')) { + data = decodeUriComponent(data); + } + return { + data: data, + mime: mime, + charset: charset, + base64: base64 + }; + }, + stringify: function(data, mime) { + var options = + arguments.length > 2 && arguments[2] !== undefined + ? arguments[2] + : {}; + defaults(options, { + base64: true, + charset: '' + }); + var result = 'data:' + mime; + if (options.charset && startWith(mime, 'text/')) { + result += ';charset=' + options.charset; + } + if (!isStr(data)) { + data = convertBin(data, 'base64'); + options.base64 = true; + } + if (options.base64) { + result += ';base64'; + } else if (startWith(mime, 'text/') || !mime) { + data = encodeURIComponent(data); + } + return result + ',' + data; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/dateFormat.js b/src/miniprogram_npm/miniprogram-licia/dateFormat.js new file mode 100644 index 0000000..a61ed69 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/dateFormat.js @@ -0,0 +1,142 @@ +var isStr = require('./isStr'); +var isDate = require('./isDate'); +var toStr = require('./toStr'); +var lpad = require('./lpad'); +exports = function(date, mask, utc, gmt) { + if (arguments.length === 1 && isStr(date) && !regNum.test(date)) { + mask = date; + date = undefined; + } + date = date || new Date(); + if (!isDate(date)) date = new Date(date); + mask = toStr(exports.masks[mask] || mask || exports.masks['default']); + var maskSlice = mask.slice(0, 4); + if (maskSlice === 'UTC:' || maskSlice === 'GMT:') { + mask = mask.slice(4); + utc = true; + if (maskSlice === 'GMT:') gmt = true; + } + var prefix = utc ? 'getUTC' : 'get'; + var d = date[prefix + 'Date'](); + var D = date[prefix + 'Day'](); + var m = date[prefix + 'Month'](); + var y = date[prefix + 'FullYear'](); + var H = date[prefix + 'Hours'](); + var M = date[prefix + 'Minutes'](); + var s = date[prefix + 'Seconds'](); + var L = date[prefix + 'Milliseconds'](); + var o = utc ? 0 : date.getTimezoneOffset(); + var flags = { + d: d, + dd: padZero(d), + ddd: exports.i18n.dayNames[D], + dddd: exports.i18n.dayNames[D + 7], + m: m + 1, + mm: padZero(m + 1), + mmm: exports.i18n.monthNames[m], + mmmm: exports.i18n.monthNames[m + 12], + yy: toStr(y).slice(2), + yyyy: y, + h: H % 12 || 12, + hh: padZero(H % 12 || 12), + H: H, + HH: padZero(H), + M: M, + MM: padZero(M), + s: s, + ss: padZero(s), + l: padZero(L, 3), + L: padZero(Math.round(L / 10)), + t: H < 12 ? 'a' : 'p', + tt: H < 12 ? 'am' : 'pm', + T: H < 12 ? 'A' : 'P', + TT: H < 12 ? 'AM' : 'PM', + Z: gmt + ? 'GMT' + : utc + ? 'UTC' + : (toStr(date).match(regTimezone) || ['']) + .pop() + .replace(regTimezoneClip, ''), + o: + (o > 0 ? '-' : '+') + + padZero(Math.floor(Math.abs(o) / 60) * 100 + (Math.abs(o) % 60), 4), + S: ['th', 'st', 'nd', 'rd'][ + d % 10 > 3 ? 0 : (((d % 100) - (d % 10) != 10) * d) % 10 + ] + }; + return mask.replace(regToken, function(match) { + if (match in flags) return flags[match]; + return match.slice(1, match.length - 1); + }); +}; +var padZero = function(str) { + var len = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2; + return lpad(toStr(str), len, '0'); +}; +var regToken = /d{1,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|[LloSZWN]|"[^"]*"|'[^']*'/g; +var regTimezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g; +var regNum = /\d/; +var regTimezoneClip = /[^-+\dA-Z]/g; +exports.masks = { + default: 'ddd mmm dd yyyy HH:MM:ss', + shortDate: 'm/d/yy', + mediumDate: 'mmm d, yyyy', + longDate: 'mmmm d, yyyy', + fullDate: 'dddd, mmmm d, yyyy', + shortTime: 'h:MM TT', + mediumTime: 'h:MM:ss TT', + longTime: 'h:MM:ss TT Z', + isoDate: 'yyyy-mm-dd', + isoTime: 'HH:MM:ss', + isoDateTime: "yyyy-mm-dd'T'HH:MM:sso", + isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'", + expiresHeaderFormat: 'ddd, dd mmm yyyy HH:MM:ss Z' +}; +exports.i18n = { + dayNames: [ + 'Sun', + 'Mon', + 'Tue', + 'Wed', + 'Thu', + 'Fri', + 'Sat', + 'Sunday', + 'Monday', + 'Tuesday', + 'Wednesday', + 'Thursday', + 'Friday', + 'Saturday' + ], + monthNames: [ + 'Jan', + 'Feb', + 'Mar', + 'Apr', + 'May', + 'Jun', + 'Jul', + 'Aug', + 'Sep', + 'Oct', + 'Nov', + 'Dec', + 'January', + 'February', + 'March', + 'April', + 'May', + 'June', + 'July', + 'August', + 'September', + 'October', + 'November', + 'December' + ] +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/debounce.js b/src/miniprogram_npm/miniprogram-licia/debounce.js new file mode 100644 index 0000000..6c2d322 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/debounce.js @@ -0,0 +1,15 @@ +exports = function(fn, wait, immediate) { + var timeout; + return function() { + var ctx = this; + var args = arguments; + var throttler = function() { + timeout = null; + fn.apply(ctx, args); + }; + if (!immediate) clearTimeout(timeout); + if (!immediate || !timeout) timeout = setTimeout(throttler, wait); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/deburr.js b/src/miniprogram_npm/miniprogram-licia/deburr.js new file mode 100644 index 0000000..b930e07 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/deburr.js @@ -0,0 +1,206 @@ +exports = function(str) { + return str + .replace(regLatin, function(key) { + return deburredLetters[key]; + }) + .replace(regComboMark, ''); +}; + +var regComboMark = /[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]/g; +var regLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + +var deburredLetters = { + À: 'A', + Á: 'A', + Â: 'A', + Ã: 'A', + Ä: 'A', + Å: 'A', + à: 'a', + á: 'a', + â: 'a', + ã: 'a', + ä: 'a', + å: 'a', + Ç: 'C', + ç: 'c', + Ð: 'D', + ð: 'd', + È: 'E', + É: 'E', + Ê: 'E', + Ë: 'E', + è: 'e', + é: 'e', + ê: 'e', + ë: 'e', + Ì: 'I', + Í: 'I', + Î: 'I', + Ï: 'I', + ì: 'i', + í: 'i', + î: 'i', + ï: 'i', + Ñ: 'N', + ñ: 'n', + Ò: 'O', + Ó: 'O', + Ô: 'O', + Õ: 'O', + Ö: 'O', + Ø: 'O', + ò: 'o', + ó: 'o', + ô: 'o', + õ: 'o', + ö: 'o', + ø: 'o', + Ù: 'U', + Ú: 'U', + Û: 'U', + Ü: 'U', + ù: 'u', + ú: 'u', + û: 'u', + ü: 'u', + Ý: 'Y', + ý: 'y', + ÿ: 'y', + Æ: 'Ae', + æ: 'ae', + Þ: 'Th', + þ: 'th', + ß: 'ss', + + Ā: 'A', + Ă: 'A', + Ą: 'A', + ā: 'a', + ă: 'a', + ą: 'a', + Ć: 'C', + Ĉ: 'C', + Ċ: 'C', + Č: 'C', + ć: 'c', + ĉ: 'c', + ċ: 'c', + č: 'c', + Ď: 'D', + Đ: 'D', + ď: 'd', + đ: 'd', + Ē: 'E', + Ĕ: 'E', + Ė: 'E', + Ę: 'E', + Ě: 'E', + ē: 'e', + ĕ: 'e', + ė: 'e', + ę: 'e', + ě: 'e', + Ĝ: 'G', + Ğ: 'G', + Ġ: 'G', + Ģ: 'G', + ĝ: 'g', + ğ: 'g', + ġ: 'g', + ģ: 'g', + Ĥ: 'H', + Ħ: 'H', + ĥ: 'h', + ħ: 'h', + Ĩ: 'I', + Ī: 'I', + Ĭ: 'I', + Į: 'I', + İ: 'I', + ĩ: 'i', + ī: 'i', + ĭ: 'i', + į: 'i', + ı: 'i', + Ĵ: 'J', + ĵ: 'j', + Ķ: 'K', + ķ: 'k', + ĸ: 'k', + Ĺ: 'L', + Ļ: 'L', + Ľ: 'L', + Ŀ: 'L', + Ł: 'L', + ĺ: 'l', + ļ: 'l', + ľ: 'l', + ŀ: 'l', + ł: 'l', + Ń: 'N', + Ņ: 'N', + Ň: 'N', + Ŋ: 'N', + ń: 'n', + ņ: 'n', + ň: 'n', + ŋ: 'n', + Ō: 'O', + Ŏ: 'O', + Ő: 'O', + ō: 'o', + ŏ: 'o', + ő: 'o', + Ŕ: 'R', + Ŗ: 'R', + Ř: 'R', + ŕ: 'r', + ŗ: 'r', + ř: 'r', + Ś: 'S', + Ŝ: 'S', + Ş: 'S', + Š: 'S', + ś: 's', + ŝ: 's', + ş: 's', + š: 's', + Ţ: 'T', + Ť: 'T', + Ŧ: 'T', + ţ: 't', + ť: 't', + ŧ: 't', + Ũ: 'U', + Ū: 'U', + Ŭ: 'U', + Ů: 'U', + Ű: 'U', + Ų: 'U', + ũ: 'u', + ū: 'u', + ŭ: 'u', + ů: 'u', + ű: 'u', + ų: 'u', + Ŵ: 'W', + ŵ: 'w', + Ŷ: 'Y', + ŷ: 'y', + Ÿ: 'Y', + Ź: 'Z', + Ż: 'Z', + Ž: 'Z', + ź: 'z', + ż: 'z', + ž: 'z', + IJ: 'IJ', + ij: 'ij', + Œ: 'Oe', + œ: 'oe', + ʼn: "'n", + ſ: 's' +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/decodeUriComponent.js b/src/miniprogram_npm/miniprogram-licia/decodeUriComponent.js new file mode 100644 index 0000000..f363d60 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/decodeUriComponent.js @@ -0,0 +1,31 @@ +var each = require('./each'); +var ucs2 = require('./ucs2'); +var map = require('./map'); +var utf8 = require('./utf8'); +exports = function(str) { + try { + return decodeURIComponent(str); + } catch (e) { + var matches = str.match(regMatcher); + if (!matches) { + return str; + } + each(matches, function(match) { + str = str.replace(match, decode(match)); + }); + return str; + } +}; +function decode(str) { + str = str.split('%').slice(1); + var bytes = map(str, hexToInt); + str = ucs2.encode(bytes); + str = utf8.decode(str, true); + return str; +} +function hexToInt(numStr) { + return +('0x' + numStr); +} +var regMatcher = /(%[a-f0-9]{2})+/gi; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/defaults.js b/src/miniprogram_npm/miniprogram-licia/defaults.js new file mode 100644 index 0000000..942d2e8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/defaults.js @@ -0,0 +1,5 @@ +var createAssigner = require('./createAssigner'); +var allKeys = require('./allKeys'); +exports = createAssigner(allKeys, true); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/define.js b/src/miniprogram_npm/miniprogram-licia/define.js new file mode 100644 index 0000000..bea82fd --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/define.js @@ -0,0 +1,17 @@ +var toArr = require('./toArr'); +exports = function(name, requires, method) { + if (arguments.length === 2) { + method = requires; + requires = []; + } + define(name, requires, method); +}; +var modules = (exports._modules = {}); +function define(name, requires, method) { + modules[name] = { + requires: toArr(requires), + body: method + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/defineProp.js b/src/miniprogram_npm/miniprogram-licia/defineProp.js new file mode 100644 index 0000000..b331320 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/defineProp.js @@ -0,0 +1,26 @@ +var castPath = require('./castPath'); +var isStr = require('./isStr'); +var isObj = require('./isObj'); +var each = require('./each'); +exports = function(obj, prop, descriptor) { + if (isStr(prop)) { + defineProp(obj, prop, descriptor); + } else if (isObj(prop)) { + each(prop, function(descriptor, prop) { + defineProp(obj, prop, descriptor); + }); + } + return obj; +}; +function defineProp(obj, prop, descriptor) { + var path = castPath(prop, obj); + var lastProp = path.pop(); + + while ((prop = path.shift())) { + if (!obj[prop]) obj[prop] = {}; + obj = obj[prop]; + } + Object.defineProperty(obj, lastProp, descriptor); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/defined.js b/src/miniprogram_npm/miniprogram-licia/defined.js new file mode 100644 index 0000000..3ee1db6 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/defined.js @@ -0,0 +1,8 @@ +var isUndef = require('./isUndef'); +exports = function() { + for (var i = 0, len = arguments.length; i < len; i++) { + if (!isUndef(arguments[i])) return arguments[i]; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/delay.js b/src/miniprogram_npm/miniprogram-licia/delay.js new file mode 100644 index 0000000..393fe77 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/delay.js @@ -0,0 +1,8 @@ +var restArgs = require('./restArgs'); +exports = restArgs(function(fn, wait, args) { + return setTimeout(function() { + return fn.apply(null, args); + }, wait); +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/deprecate.js b/src/miniprogram_npm/miniprogram-licia/deprecate.js new file mode 100644 index 0000000..822a31a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/deprecate.js @@ -0,0 +1,36 @@ +var isNode = require('./isNode'); +var root = require('./root'); +var memStorage = require('./memStorage'); +if (isNode) { + exports = eval('require')('util').deprecate; +} else { + var localStorage = root.localStorage || memStorage; + exports = function(fn, msg) { + if (localStorage.getItem('noDeprecation')) { + return fn; + } + var warned = false; + function deprecated() { + if (!warned) { + warned = true; + + console.warn(msg); + } + for ( + var _len = arguments.length, args = new Array(_len), _key = 0; + _key < _len; + _key++ + ) { + args[_key] = arguments[_key]; + } + return fn.apply(this, args); + } + Object.setPrototypeOf(deprecated, fn); + if (fn.prototype) { + deprecated.prototype = fn.prototype; + } + return deprecated; + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/detectBrowser.js b/src/miniprogram_npm/miniprogram-licia/detectBrowser.js new file mode 100644 index 0000000..66843ac --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/detectBrowser.js @@ -0,0 +1,51 @@ +var isBrowser = require('./isBrowser'); +var toInt = require('./toInt'); +var keys = require('./keys'); +exports = function(ua) { + ua = ua || (isBrowser ? navigator.userAgent : ''); + ua = ua.toLowerCase(); + var ieVer = getVer(ua, 'msie '); + if (ieVer) + return { + version: ieVer, + name: 'ie' + }; + if (regIe11.test(ua)) + return { + version: 11, + name: 'ie' + }; + for (var i = 0, len = browsers.length; i < len; i++) { + var name = browsers[i]; + var match = ua.match(regBrowsers[name]); + if (match == null) continue; + var version = toInt(match[1].split('.')[0]); + if (name === 'opera') version = getVer(ua, 'version/') || version; + return { + name: name, + version: version + }; + } + return { + name: 'unknown', + version: -1 + }; +}; +var regBrowsers = { + edge: /edge\/([0-9._]+)/, + firefox: /firefox\/([0-9.]+)(?:\s|$)/, + opera: /opera\/([0-9.]+)(?:\s|$)/, + android: /android\s([0-9.]+)/, + ios: /version\/([0-9._]+).*mobile.*safari.*/, + safari: /version\/([0-9._]+).*safari/, + chrome: /(?!chrom.*opr)chrom(?:e|ium)\/([0-9.]+)(:?\s|$)/ +}; +var regIe11 = /trident\/7\./; +var browsers = keys(regBrowsers); +function getVer(ua, mark) { + var idx = ua.indexOf(mark); + if (idx > -1) + return toInt(ua.substring(idx + mark.length, ua.indexOf('.', idx))); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/detectMocha.js b/src/miniprogram_npm/miniprogram-licia/detectMocha.js new file mode 100644 index 0000000..b0c51d3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/detectMocha.js @@ -0,0 +1,11 @@ +var root = require('./root'); +exports = function() { + for (var i = 0, len = methods.length; i < len; i++) { + var method = methods[i]; + if (typeof root[method] !== 'function') return false; + } + return true; +}; +var methods = ['afterEach', 'after', 'beforeEach', 'before', 'describe', 'it']; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/detectOs.js b/src/miniprogram_npm/miniprogram-licia/detectOs.js new file mode 100644 index 0000000..4edc766 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/detectOs.js @@ -0,0 +1,39 @@ +var isBrowser = require('./isBrowser'); +var isNode = require('./isNode'); +exports = function(ua) { + if (!ua && isBrowser) { + ua = navigator.userAgent; + } + function detect(keyword) { + return ua.indexOf(keyword) > -1; + } + if (ua) { + ua = ua.toLowerCase(); + if (detect('windows phone')) return 'windows phone'; + if (detect('win')) return 'windows'; + if (detect('android')) return 'android'; + if (detect('ipad') || detect('iphone') || detect('ipod')) return 'ios'; + if (detect('mac')) return 'os x'; + if (detect('linux')) return 'linux'; + } else if (isNode) { + var _process = process, + platform = _process.platform, + env = _process.env; + if ( + platform === 'win32' || + env.OSTYPE === 'cygwin' || + env.OSTYPE === 'msys' + ) { + return 'windows'; + } + if (platform === 'darwin') { + return 'os x'; + } + if (platform === 'linux') { + return 'linux'; + } + } + return 'unknown'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/difference.js b/src/miniprogram_npm/miniprogram-licia/difference.js new file mode 100644 index 0000000..8e5d16f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/difference.js @@ -0,0 +1,12 @@ +var restArgs = require('./restArgs'); +var flatten = require('./flatten'); +var filter = require('./filter'); +var contain = require('./contain'); +exports = restArgs(function(arr, args) { + args = flatten(args); + return filter(arr, function(val) { + return !contain(args, val); + }); +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/dotCase.js b/src/miniprogram_npm/miniprogram-licia/dotCase.js new file mode 100644 index 0000000..a88fb5b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/dotCase.js @@ -0,0 +1,6 @@ +var splitCase = require('./splitCase'); +exports = function(str) { + return splitCase(str).join('.'); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/durationFormat.js b/src/miniprogram_npm/miniprogram-licia/durationFormat.js new file mode 100644 index 0000000..7beda3e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/durationFormat.js @@ -0,0 +1,39 @@ +var toInt = require('./toInt'); +var lpad = require('./lpad'); +var toStr = require('./toStr'); +var floor = Math.floor; +exports = function(duration) { + var mask = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : 'hh:mm:ss'; + duration = toInt(duration); + var d = floor(duration / 86400000); + var h = floor(duration / 3600000) % 24; + var m = floor(duration / 60000) % 60; + var s = floor(duration / 1000) % 60; + var l = floor(duration) % 1000; + var flags = { + d: d, + h: h, + hh: padZero(h), + m: m, + mm: padZero(m), + s: s, + ss: padZero(s), + l: l, + ll: padZero(l, 3) + }; + return mask.replace(regToken, function(match) { + if (match in flags) return flags[match]; + return match.slice(1, match.length - 1); + }); +}; +var padZero = function(str) { + var len = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2; + return lpad(toStr(str), len, '0'); +}; +var regToken = /d{1,2}|h{1,2}|m{1,2}|s{1,2}|l{1,2}|"[^"]*"|'[^']*'/g; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/each.js b/src/miniprogram_npm/miniprogram-licia/each.js new file mode 100644 index 0000000..0020098 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/each.js @@ -0,0 +1,18 @@ +var isArrLike = require('./isArrLike'); +var keys = require('./keys'); +var optimizeCb = require('./optimizeCb'); +exports = function(obj, iterator, ctx) { + iterator = optimizeCb(iterator, ctx); + var i, len; + if (isArrLike(obj)) { + for (i = 0, len = obj.length; i < len; i++) iterator(obj[i], i, obj); + } else { + var _keys = keys(obj); + for (i = 0, len = _keys.length; i < len; i++) { + iterator(obj[_keys[i]], _keys[i], obj); + } + } + return obj; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/easing.js b/src/miniprogram_npm/miniprogram-licia/easing.js new file mode 100644 index 0000000..a6a5b93 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/easing.js @@ -0,0 +1,63 @@ +var each = require('./each'); +var upperFirst = require('./upperFirst'); +exports.linear = function(t) { + return t; +}; +var pow = Math.pow; +var sqrt = Math.sqrt; +var sin = Math.sin; +var min = Math.min; +var asin = Math.asin; +var PI = Math.PI; +var fns = { + sine: function(t) { + return 1 + sin((PI / 2) * t - PI / 2); + }, + circ: function(t) { + return 1 - sqrt(1 - t * t); + }, + elastic: function(t, m) { + m = m || DEFAULT_ELASTICITY; + if (t === 0 || t === 1) return t; + var p = 1 - min(m, 998) / 1000; + var st = t / 1; + var st1 = st - 1; + var s = (p / (2 * PI)) * asin(1); + return -(pow(2, 10 * st1) * sin(((st1 - s) * (2 * PI)) / p)); + }, + back: function(t) { + return t * t * (3 * t - 2); + }, + bounce: function(t) { + var pow2, + bounce = 4; + + while (t < ((pow2 = pow(2, --bounce)) - 1) / 11) {} + return ( + 1 / pow(4, 3 - bounce) - 7.5625 * pow((pow2 * 3 - 2) / 22 - t, 2) + ); + } +}; +each(['quad', 'cubic', 'quart', 'quint', 'expo'], function(name, i) { + fns[name] = function(t) { + return pow(t, i + 2); + }; +}); +var DEFAULT_ELASTICITY = 400; +each(fns, function(fn, name) { + name = upperFirst(name); + exports['in' + name] = fn; + exports['out' + name] = function(t, m) { + return 1 - fn(1 - t, m); + }; + exports['inOut' + name] = function(t, m) { + return t < 0.5 ? fn(t * 2, m) / 2 : 1 - fn(t * -2 + 2, m) / 2; + }; + exports['outIn' + name] = function(t, m) { + return t < 0.5 + ? (1 - fn(1 - 2 * t, m)) / 2 + : (fn(t * 2 - 1, m) + 1) / 2; + }; +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/endWith.js b/src/miniprogram_npm/miniprogram-licia/endWith.js new file mode 100644 index 0000000..76a8d3c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/endWith.js @@ -0,0 +1,6 @@ +exports = function(str, suffix) { + var idx = str.length - suffix.length; + return idx >= 0 && str.indexOf(suffix, idx) === idx; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/escape.js b/src/miniprogram_npm/miniprogram-licia/escape.js new file mode 100644 index 0000000..89174e8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/escape.js @@ -0,0 +1,20 @@ +var keys = require('./keys'); +exports = function(str) { + return regTest.test(str) ? str.replace(regReplace, replaceFn) : str; +}; +var map = (exports.map = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`' +}); +var regSrc = '(?:' + keys(map).join('|') + ')'; +var regTest = new RegExp(regSrc); +var regReplace = new RegExp(regSrc, 'g'); +var replaceFn = function(match) { + return map[match]; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/escapeJsStr.js b/src/miniprogram_npm/miniprogram-licia/escapeJsStr.js new file mode 100644 index 0000000..7be9750 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/escapeJsStr.js @@ -0,0 +1,24 @@ +var toStr = require('./toStr'); +exports = function(str) { + return toStr(str).replace(regEscapeChars, function(char) { + switch (char) { + case '"': + case "'": + case '\\': + return '\\' + char; + case '\n': + return '\\n'; + case '\r': + return '\\r'; + // Line separator + case '\u2028': + return '\\u2028'; + // Paragraph separator + case '\u2029': + return '\\u2029'; + } + }); +}; +var regEscapeChars = /["'\\\n\r\u2028\u2029]/g; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/escapeRegExp.js b/src/miniprogram_npm/miniprogram-licia/escapeRegExp.js new file mode 100644 index 0000000..0c7d3b5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/escapeRegExp.js @@ -0,0 +1,5 @@ +exports = function(str) { + return str.replace(/\W/g, '\\$&'); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/every.js b/src/miniprogram_npm/miniprogram-licia/every.js new file mode 100644 index 0000000..4fde31e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/every.js @@ -0,0 +1,15 @@ +var safeCb = require('./safeCb'); +var isArrLike = require('./isArrLike'); +var keys = require('./keys'); +exports = function(obj, predicate, ctx) { + predicate = safeCb(predicate, ctx); + var _keys = !isArrLike(obj) && keys(obj); + var len = (_keys || obj).length; + for (var i = 0; i < len; i++) { + var curKey = _keys ? _keys[i] : i; + if (!predicate(obj[curKey], curKey, obj)) return false; + } + return true; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/extend.js b/src/miniprogram_npm/miniprogram-licia/extend.js new file mode 100644 index 0000000..09aaeb4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/extend.js @@ -0,0 +1,5 @@ +var createAssigner = require('./createAssigner'); +var allKeys = require('./allKeys'); +exports = createAssigner(allKeys); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/extendDeep.js b/src/miniprogram_npm/miniprogram-licia/extendDeep.js new file mode 100644 index 0000000..38ede04 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/extendDeep.js @@ -0,0 +1,28 @@ +var isPlainObj = require('./isPlainObj'); +var each = require('./each'); +var cloneDeep = require('./cloneDeep'); +exports = function(obj) { + var i = 0; + var ret = obj; + var len = arguments.length; + while (++i < len) { + obj = arguments[i]; + if (isPlainObj(ret) && isPlainObj(obj)) { + each(obj, function(val, key) { + if ( + key === '__proto__' || + key === 'constructor' || + key === 'prototype' + ) { + return; + } + ret[key] = exports(ret[key], obj[key]); + }); + } else { + ret = cloneDeep(obj); + } + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/extendOwn.js b/src/miniprogram_npm/miniprogram-licia/extendOwn.js new file mode 100644 index 0000000..c093f30 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/extendOwn.js @@ -0,0 +1,5 @@ +var keys = require('./keys'); +var createAssigner = require('./createAssigner'); +exports = createAssigner(keys); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/extractBlockCmts.js b/src/miniprogram_npm/miniprogram-licia/extractBlockCmts.js new file mode 100644 index 0000000..08a08fc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/extractBlockCmts.js @@ -0,0 +1,17 @@ +var map = require('./map'); +var trim = require('./trim'); +var regBlockCmt = /(\/\*[\s\S]*?\*\/)/gm; +exports = function(str) { + var ret = str.match(regBlockCmt); + if (!ret) return []; + ret = map(ret, function(comment) { + return trim( + map(comment.split('\n'), function(line) { + return trim(line).replace(/^\/\*+|\*+\/$|^\*+/g, ''); + }).join('\n') + ); + }); + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/extractUrls.js b/src/miniprogram_npm/miniprogram-licia/extractUrls.js new file mode 100644 index 0000000..6799c3a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/extractUrls.js @@ -0,0 +1,15 @@ +var unique = require('./unique'); +var trim = require('./trim'); +var map = require('./map'); +var toArr = require('./toArr'); +exports = function(str) { + var urlList = toArr(str.match(regUrl)); + return unique( + map(urlList, function(url) { + return trim(url); + }) + ); +}; +var regUrl = /((https?)|(ftp)):\/\/[\w.]+[^ \f\n\r\t\v"\\<>[\]\u2100-\uFFFF(),]*/gi; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fibonacci.js b/src/miniprogram_npm/miniprogram-licia/fibonacci.js new file mode 100644 index 0000000..a916028 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fibonacci.js @@ -0,0 +1,6 @@ +var memoize = require('./memoize'); +exports = memoize(function(n) { + return n < 2 ? n : exports(n - 1) + exports(n - 2); +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fileSize.js b/src/miniprogram_npm/miniprogram-licia/fileSize.js new file mode 100644 index 0000000..80fb0ef --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fileSize.js @@ -0,0 +1,9 @@ +exports = function(bytes) { + if (bytes <= 0) return '0'; + var suffixIdx = Math.floor(Math.log(bytes) / Math.log(1024)); + var val = bytes / Math.pow(2, suffixIdx * 10); + return +val.toFixed(2) + suffixList[suffixIdx]; +}; +var suffixList = ['', 'K', 'M', 'G', 'T']; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fileType.js b/src/miniprogram_npm/miniprogram-licia/fileType.js new file mode 100644 index 0000000..453d844 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fileType.js @@ -0,0 +1,148 @@ +function _slicedToArray(r, e) { + return ( + _arrayWithHoles(r) || + _iterableToArrayLimit(r, e) || + _unsupportedIterableToArray(r, e) || + _nonIterableRest() + ); +} +function _nonIterableRest() { + throw new TypeError( + 'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.' + ); +} +function _unsupportedIterableToArray(r, a) { + if (r) { + if ('string' == typeof r) return _arrayLikeToArray(r, a); + var t = {}.toString.call(r).slice(8, -1); + return ( + 'Object' === t && r.constructor && (t = r.constructor.name), + 'Map' === t || 'Set' === t + ? Array.from(r) + : 'Arguments' === t || + /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) + ? _arrayLikeToArray(r, a) + : void 0 + ); + } +} +function _arrayLikeToArray(r, a) { + (null == a || a > r.length) && (a = r.length); + for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; + return n; +} +function _iterableToArrayLimit(r, l) { + var t = + null == r + ? null + : ('undefined' != typeof Symbol && r[Symbol.iterator]) || + r['@@iterator']; + if (null != t) { + var e, + n, + i, + u, + a = [], + f = !0, + o = !1; + try { + if (((i = (t = t.call(r)).next), 0 === l)) { + if (Object(t) !== t) return; + f = !1; + } else + for ( + ; + !(f = (e = i.call(t)).done) && + (a.push(e.value), a.length !== l); + f = !0 + ); + } catch (r) { + (o = !0), (n = r); + } finally { + try { + if ( + !f && + null != t.return && + ((u = t.return()), Object(u) !== u) + ) + return; + } finally { + if (o) throw n; + } + } + return a; + } +} +function _arrayWithHoles(r) { + if (Array.isArray(r)) return r; +} + +var type = require('./type'); +var mime = require('./mime'); +var isFn = require('./isFn'); +exports = function(input) { + if (type(input) !== 'uint8array') { + input = new Uint8Array(input); + } + for (var i = 0, len = types.length; i < len; i++) { + var _type = types[i]; + var _type2 = _slicedToArray(_type, 3), + ext = _type2[0], + magic = _type2[1], + offset = _type2[2]; + if (isFn(magic)) { + if (magic(input)) { + return { + ext: ext, + mime: mime(ext) + }; + } + } else if (check(input, magic, offset)) { + return { + ext: ext, + mime: mime(ext) + }; + } + } +}; +var types = [ + ['jpg', [0xff, 0xd8, 0xff]], + ['png', [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]], + ['gif', [0x47, 0x49, 0x46]], + ['webp', [0x57, 0x45, 0x42, 0x50], 8], + ['bmp', [0x42, 0x4d]], + ['gz', [0x1f, 0x8b, 0x8]], + [ + 'zip', + function(input) { + return ( + check(input, [0x50, 0x4b]) && + (input[2] === 0x3 || input[2] === 0x5 || input[2] === 0x7) && + (input[3] === 0x4 || input[3] === 0x6 || input[3] === 0x8) + ); + } + ], + [ + 'rar', + function(input) { + return ( + check(input, [0x52, 0x61, 0x72, 0x21, 0x1a, 0x7]) && + (input[6] === 0x0 || input[6] === 0x1) + ); + } + ], + ['pdf', [0x25, 0x50, 0x44, 0x46]], + ['exe', [0x4d, 0x5a]] +]; +function check(input, magic) { + var offset = + arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + for (var i = 0, len = magic.length; i < len; i++) { + if (input[offset + i] !== magic[i]) { + return false; + } + } + return true; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fileUrl.js b/src/miniprogram_npm/miniprogram-licia/fileUrl.js new file mode 100644 index 0000000..2643a8b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fileUrl.js @@ -0,0 +1,13 @@ +var normalizePath = require('./normalizePath'); +exports = function(path) { + path = normalizePath(path); + if (path[0] !== '/') { + path = '/'.concat(path); + } + return encodeURI('file://'.concat(path)).replace( + /[?#]/g, + encodeURIComponent + ); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fill.js b/src/miniprogram_npm/miniprogram-licia/fill.js new file mode 100644 index 0000000..2c9d150 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fill.js @@ -0,0 +1,11 @@ +var isUndef = require('./isUndef'); +exports = function(arr, val, start, end) { + var len = arr.length; + if (!len) return []; + if (isUndef(end)) end = len; + if (isUndef(start)) start = 0; + while (start < end) arr[start++] = val; + return arr; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/filter.js b/src/miniprogram_npm/miniprogram-licia/filter.js new file mode 100644 index 0000000..941082d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/filter.js @@ -0,0 +1,12 @@ +var safeCb = require('./safeCb'); +var each = require('./each'); +exports = function(obj, predicate, ctx) { + var ret = []; + predicate = safeCb(predicate, ctx); + each(obj, function(val, idx, list) { + if (predicate(val, idx, list)) ret.push(val); + }); + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/find.js b/src/miniprogram_npm/miniprogram-licia/find.js new file mode 100644 index 0000000..b5ff0de --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/find.js @@ -0,0 +1,11 @@ +var findKey = require('./findKey'); +var findIdx = require('./findIdx'); +var isArrLike = require('./isArrLike'); +var isUndef = require('./isUndef'); +exports = function(obj, predicate, ctx) { + var keyFinder = isArrLike(obj) ? findIdx : findKey; + var key = keyFinder(obj, predicate, ctx); + if (!isUndef(key) && key !== -1) return obj[key]; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/findIdx.js b/src/miniprogram_npm/miniprogram-licia/findIdx.js new file mode 100644 index 0000000..023068c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/findIdx.js @@ -0,0 +1,14 @@ +var safeCb = require('./safeCb'); +exports = function(arr, predicate, ctx, dir) { + dir = dir || 1; + predicate = safeCb(predicate, ctx); + var len = arr.length; + var i = dir > 0 ? 0 : len - 1; + while (i >= 0 && i < len) { + if (predicate(arr[i], i, arr)) return i; + i += dir; + } + return -1; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/findKey.js b/src/miniprogram_npm/miniprogram-licia/findKey.js new file mode 100644 index 0000000..663c802 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/findKey.js @@ -0,0 +1,13 @@ +var safeCb = require('./safeCb'); +var keys = require('./keys'); +exports = function(obj, predicate, ctx) { + predicate = safeCb(predicate, ctx); + var _keys = keys(obj); + var key; + for (var i = 0, len = _keys.length; i < len; i++) { + key = _keys[i]; + if (predicate(obj[key], key, obj)) return key; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/findLastIdx.js b/src/miniprogram_npm/miniprogram-licia/findLastIdx.js new file mode 100644 index 0000000..375bcf1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/findLastIdx.js @@ -0,0 +1,6 @@ +var findIdx = require('./findIdx'); +exports = function(arr, predicate, ctx) { + return findIdx(arr, predicate, ctx, -1); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/flatten.js b/src/miniprogram_npm/miniprogram-licia/flatten.js new file mode 100644 index 0000000..53290e9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/flatten.js @@ -0,0 +1,16 @@ +var isArr = require('./isArr'); +exports = function(arr) { + return flat(arr, []); +}; +function flat(arr, res) { + var len = arr.length, + i = -1, + cur; + while (len--) { + cur = arr[++i]; + isArr(cur) ? flat(cur, res) : res.push(cur); + } + return res; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fnArgs.js b/src/miniprogram_npm/miniprogram-licia/fnArgs.js new file mode 100644 index 0000000..697e1e0 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fnArgs.js @@ -0,0 +1,68 @@ +var startWith = require('./startWith'); +var last = require('./last'); +var lowerCase = require('./lowerCase'); +var isObj = require('./isObj'); +var type = require('./type'); +exports = function(types, args) { + var argsLen = args.length; + var typesLen = types.length; + var minLen = typesLen; + var maxLen = typesLen; + for (var i = 0; i < typesLen; i++) { + var _type = types[i].split('|'); + if (startWith(_type[0], '?')) { + _type[0] = _type[0].slice(1); + if (minLen === typesLen) { + minLen = i; + } + } + if (i === typesLen - 1 && startWith(_type[0], '...')) { + maxLen = Infinity; + _type[0] = _type[0].slice(3); + if (minLen === typesLen) { + minLen = i; + } + } + types[i] = _type; + } + if (argsLen < minLen) { + throw Error( + 'Expected at least ' + .concat(minLen, ' args but got ') + .concat(argsLen) + ); + } else if (argsLen > maxLen) { + throw Error( + 'Expected at most '.concat(maxLen, ' args but got ').concat(argsLen) + ); + } + for (var _i = 0; _i < argsLen; _i++) { + var arg = args[_i]; + if (_i >= typesLen) { + validateArg(arg, last(types), _i); + } else { + validateArg(arg, types[_i], _i); + } + } +}; +function validateArg(value, types, num) { + var isValid = false; + for (var i = 0, len = types.length; i < len; i++) { + var t = lowerCase(types[i]); + if ( + t === 'any' || + (t === 'object' && isObj(value)) || + type(value) === t + ) { + isValid = true; + break; + } + } + if (!isValid) { + throw TypeError( + 'Argument '.concat(num, ' should be type ').concat(types.join('|')) + ); + } +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fnParams.js b/src/miniprogram_npm/miniprogram-licia/fnParams.js new file mode 100644 index 0000000..65bcdd7 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fnParams.js @@ -0,0 +1,26 @@ +var toSrc = require('./toSrc'); +var stripCmt = require('./stripCmt'); +var startWith = require('./startWith'); +var isStr = require('./isStr'); +exports = function(fn) { + var fnStr = stripCmt(isStr(fn) ? fn : toSrc(fn)); + var open; + var close; + if ( + !startWith(fnStr, 'async') && + !startWith(fnStr, 'function') && + !startWith(fnStr, '(') + ) { + open = 0; + close = fnStr.indexOf('=>'); + } else { + open = fnStr.indexOf('(') + 1; + close = fnStr.indexOf(')'); + } + var ret = fnStr.slice(open, close); + ret = ret.match(regArgNames); + return ret === null ? [] : ret; +}; +var regArgNames = /[^\s,]+/g; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fnv1a.js b/src/miniprogram_npm/miniprogram-licia/fnv1a.js new file mode 100644 index 0000000..bd5f22e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fnv1a.js @@ -0,0 +1,11 @@ +var BASE = 0x811c9dc5; +exports = function(str) { + var ret = BASE; + for (var i = 0, len = str.length; i < len; i++) { + ret ^= str.charCodeAt(i); + ret += (ret << 1) + (ret << 4) + (ret << 7) + (ret << 8) + (ret << 24); + } + return ret >>> 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/format.js b/src/miniprogram_npm/miniprogram-licia/format.js new file mode 100644 index 0000000..d407b12 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/format.js @@ -0,0 +1,45 @@ +var restArgs = require('./restArgs'); +var toInt = require('./toInt'); +var toNum = require('./toNum'); +var toStr = require('./toStr'); +exports = restArgs(function(str, values) { + var ret = ''; + for (var i = 0, len = str.length; i < len; i++) { + var c = str[i]; + if (c !== '%' || values.length === 0) { + ret += c; + continue; + } + i++; + var val = values.shift(); + switch (str[i]) { + case 'i': + case 'd': + ret += toInt(val); + break; + case 'f': + ret += toNum(val); + break; + case 's': + ret += toStr(val); + break; + case 'o': + ret += tryStringify(val); + break; + default: + i--; + values.unshift(val); + ret += c; + } + } + return ret; +}); +function tryStringify(obj) { + try { + return JSON.stringify(obj); + } catch (err) { + return '[Error Stringify]'; + } +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fraction.js b/src/miniprogram_npm/miniprogram-licia/fraction.js new file mode 100644 index 0000000..f8a6524 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fraction.js @@ -0,0 +1,17 @@ +var gcd = require('./gcd'); +var precision = require('./precision'); +exports = function(num) { + if (num === 0) return '0'; + var _precision = precision(num); + _precision = pow(10, _precision); + var numerator = num * _precision, + denominator = _precision; + var _gcd = abs(gcd(numerator, denominator)); + numerator /= _gcd; + denominator /= _gcd; + return numerator + '/' + denominator; +}; +var abs = Math.abs; +var pow = Math.pow; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/freeze.js b/src/miniprogram_npm/miniprogram-licia/freeze.js new file mode 100644 index 0000000..b13f344 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/freeze.js @@ -0,0 +1,14 @@ +var keys = require('./keys'); +exports = function(obj) { + if (Object.freeze) return Object.freeze(obj); + keys(obj).forEach(function(prop) { + if (!Object.getOwnPropertyDescriptor(obj, prop).configurable) return; + Object.defineProperty(obj, prop, { + writable: false, + configurable: false + }); + }); + return obj; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/freezeDeep.js b/src/miniprogram_npm/miniprogram-licia/freezeDeep.js new file mode 100644 index 0000000..a48306f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/freezeDeep.js @@ -0,0 +1,13 @@ +var freeze = require('./freeze'); +var keys = require('./keys'); +var isObj = require('./isObj'); +exports = function(obj) { + freeze(obj); + keys(obj).forEach(function(prop) { + var val = obj[prop]; + if (isObj(val) && !Object.isFrozen(val)) exports(val); + }); + return obj; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/fuzzySearch.js b/src/miniprogram_npm/miniprogram-licia/fuzzySearch.js new file mode 100644 index 0000000..ebe538f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/fuzzySearch.js @@ -0,0 +1,55 @@ +var filter = require('./filter'); +var map = require('./map'); +var isStr = require('./isStr'); +var safeGet = require('./safeGet'); +var levenshtein = require('./levenshtein'); +var pluck = require('./pluck'); +exports = function(needle, haystacks) { + var options = + arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + if (!options.caseSensitive) { + needle = needle.toLowerCase(); + } + haystacks = map(haystacks, function(haystack) { + var string = toStr(haystack, options); + if (!options.caseSensitive) { + string = string.toLowerCase(); + } + return { + value: haystack, + levenshtein: levenshtein(needle, string), + string: string + }; + }); + haystacks = filter(haystacks, function(haystack) { + return hasAllLetters(needle, haystack.string, options); + }); + haystacks.sort(function(a, b) { + return a.levenshtein - b.levenshtein; + }); + return pluck(haystacks, 'value'); +}; +function toStr(haystack, options) { + if (isStr(haystack)) return haystack; + return safeGet(haystack, options.key) || ''; +} +function hasAllLetters(needle, haystack) { + var hLen = haystack.length; + var nLen = needle.length; + if (nLen > hLen) return false; + if (nLen === hLen) return needle === haystack; + for (var i = 0, j = 0; i < nLen; i++) { + var c = needle.charCodeAt(i); + var has = false; + while (j < hLen) { + if (haystack.charCodeAt(j++) === c) { + has = true; + break; + } + } + if (!has) return false; + } + return true; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/gcd.js b/src/miniprogram_npm/miniprogram-licia/gcd.js new file mode 100644 index 0000000..117be5f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/gcd.js @@ -0,0 +1,6 @@ +exports = function(a, b) { + if (b === 0) return a; + return exports(b, a % b); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/getProto.js b/src/miniprogram_npm/miniprogram-licia/getProto.js new file mode 100644 index 0000000..1b3f2db --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/getProto.js @@ -0,0 +1,14 @@ +var isObj = require('./isObj'); +var isFn = require('./isFn'); +var getPrototypeOf = Object.getPrototypeOf; +var ObjectCtr = {}.constructor; +exports = function(obj) { + if (!isObj(obj)) return; + if (getPrototypeOf && !false) return getPrototypeOf(obj); + var proto = obj.__proto__; + if (proto || proto === null) return proto; + if (isFn(obj.constructor)) return obj.constructor.prototype; + if (obj instanceof ObjectCtr) return ObjectCtr.prototype; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/getUrlParam.js b/src/miniprogram_npm/miniprogram-licia/getUrlParam.js new file mode 100644 index 0000000..5260d82 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/getUrlParam.js @@ -0,0 +1,6 @@ +var Url = require('./Url'); +exports = function(name, url) { + return new Url(url).query[name]; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/golangify.js b/src/miniprogram_npm/miniprogram-licia/golangify.js new file mode 100644 index 0000000..068093d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/golangify.js @@ -0,0 +1,26 @@ +var isFn = require('./isFn'); +var restArgs = require('./restArgs'); +exports = function(fn) { + if (isFn(fn)) { + return restArgs(function(args) { + return fn + .apply(this, args) + .then(function(v) { + return [v, null]; + }) + .catch(function(err) { + return [void 0, err]; + }); + }); + } else { + return fn + .then(function(v) { + return [v, null]; + }) + .catch(function(err) { + return [void 0, err]; + }); + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/has.js b/src/miniprogram_npm/miniprogram-licia/has.js new file mode 100644 index 0000000..5b407ec --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/has.js @@ -0,0 +1,6 @@ +var hasOwnProp = Object.prototype.hasOwnProperty; +exports = function(obj, key) { + return hasOwnProp.call(obj, key); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/heapSort.js b/src/miniprogram_npm/miniprogram-licia/heapSort.js new file mode 100644 index 0000000..f9a472c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/heapSort.js @@ -0,0 +1,19 @@ +var Heap = require('./Heap'); +var isSorted = require('./isSorted'); +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : isSorted.defComparator; + var heap = new Heap(cmp); + var len = arr.length; + for (var i = 0; i < len; i++) { + heap.add(arr[i]); + } + for (var _i = 0; _i < len; _i++) { + arr[_i] = heap.poll(); + } + return arr; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/hex.js b/src/miniprogram_npm/miniprogram-licia/hex.js new file mode 100644 index 0000000..86f2594 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/hex.js @@ -0,0 +1,23 @@ +var isOdd = require('./isOdd'); +exports = { + encode: function(bytes) { + var hex = []; + for (var i = 0, len = bytes.length; i < len; i++) { + var byte = bytes[i]; + hex.push((byte >>> 4).toString(16)); + hex.push((byte & 0xf).toString(16)); + } + return hex.join(''); + }, + decode: function(str) { + var bytes = []; + var len = str.length; + if (isOdd(len)) len--; + for (var i = 0; i < len; i += 2) { + bytes.push(parseInt(str.substr(i, 2), 16)); + } + return bytes; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/highlight.js b/src/miniprogram_npm/miniprogram-licia/highlight.js new file mode 100644 index 0000000..ac8676e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/highlight.js @@ -0,0 +1,135 @@ +var each = require('./each'); +var defaults = require('./defaults'); + +exports = function(str) { + var lang = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : 'js'; + var style = + arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + defaults(style, defStyle); + str = str.replace(//g, '>'); + lang = language[lang]; + var subLangSi = 0; + var subLangs = []; + each(lang, function(val) { + if (!val.language) return; + str = str.replace(val.re, function($1, $2) { + if (!$2) { + return $1; + } + subLangs[subLangSi++] = exports($2, val.language, style); + return $1.replace($2, '___subtmpl' + (subLangSi - 1) + '___'); + }); + }); + each(lang, function(val, key) { + if (language[val.language]) return; + str = str.replace(val.re, '___' + key + '___$1___end' + key + '___'); + }); + var levels = []; + str = str.replace(/___(?!subtmpl)\w+?___/g, function($0) { + var end = $0.substr(3, 3) === 'end', + tag = (!end ? $0.substr(3) : $0.substr(6)).replace(/_/g, ''), + lastTag = levels.length > 0 ? levels[levels.length - 1] : null; + if ( + !end && + (lastTag == null || + tag == lastTag || + (lastTag != null && + lang[lastTag] && + lang[lastTag].embed != undefined && + lang[lastTag].embed.indexOf(tag) > -1)) + ) { + levels.push(tag); + return $0; + } else if (end && tag == lastTag) { + levels.pop(); + return $0; + } + return ''; + }); + each(lang, function(val, key) { + var s = style[val.style] + ? ' style="'.concat(style[val.style], '"') + : ''; + str = str + .replace(new RegExp('___end' + key + '___', 'g'), '') + .replace( + new RegExp('___' + key + '___', 'g'), + '') + ); + }); + each(lang, function(val) { + if (!val.language) return; + str = str.replace(/___subtmpl\d+___/g, function($tmpl) { + var i = parseInt($tmpl.replace(/___subtmpl(\d+)___/, '$1'), 10); + return subLangs[i]; + }); + }); + return str; +}; +var defStyle = { + comment: 'color:#63a35c;', + string: 'color:#183691;', + number: 'color:#0086b3;', + keyword: 'color:#a71d5d;', + operator: 'color:#994500;' +}; +var language = {}; +language.js = { + comment: { + re: /(\/\/.*|\/\*([\s\S]*?)\*\/)/g, + style: 'comment' + }, + string: { + re: /(('.*?')|(".*?"))/g, + style: 'string' + }, + numbers: { + re: /(-?(\d+|\d+\.\d+|\.\d+))/g, + style: 'number' + }, + keywords: { + re: /(?:\b)(function|for|foreach|while|if|else|elseif|switch|break|as|return|this|class|self|default|var|const|let|false|true|null|undefined)(?:\b)/gi, + style: 'keyword' + }, + operator: { + re: /(\+|-|\/|\*|%|=|<|>|\||\?|\.)/g, + style: 'operator' + } +}; +language.html = { + comment: { + re: /(<!--([\s\S]*?)-->)/g, + style: 'comment' + }, + tag: { + re: /(<\/?\w(.|\n)*?\/?>)/g, + style: 'keyword', + embed: ['string'] + }, + string: language.js.string, + css: { + re: /(?:<style.*?>)([\s\S]*)?(?:<\/style>)/gi, + language: 'css' + }, + script: { + re: /(?:<script.*?>)([\s\S]*?)(?:<\/script>)/gi, + language: 'js' + } +}; +language.css = { + comment: language.js.comment, + string: language.js.string, + numbers: { + re: /((-?(\d+|\d+\.\d+|\.\d+)(%|px|em|pt|in)?)|#[0-9a-fA-F]{3}[0-9a-fA-F]{3})/g, + style: 'number' + }, + keywords: { + re: /(@\w+|:?:\w+|[a-z-]+:)/g, + style: 'keyword' + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/hookFn.js b/src/miniprogram_npm/miniprogram-licia/hookFn.js new file mode 100644 index 0000000..1610e52 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/hookFn.js @@ -0,0 +1,40 @@ +var noop = require('./noop'); +var defaults = require('./defaults'); +var toArr = require('./toArr'); +var isArr = require('./isArr'); +var isErr = require('./isErr'); +exports = function(fn, options) { + defaults(options, defOptions); + return function() { + var args = toArr(arguments); + var newArgs = options.before.apply(this, args); + if (isArr(newArgs)) { + args = newArgs; + } + try { + var result = fn.apply(this, args); + var newResult = options.after.call(this, result); + if (newResult) { + result = newResult; + } + return result; + } catch (e) { + var newErr = options.error(e); + if (newErr) { + if (isErr(newErr)) { + throw newErr; + } else { + return newErr; + } + } + throw e; + } + }; +}; +var defOptions = { + before: noop, + after: noop, + error: noop +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/hslToRgb.js b/src/miniprogram_npm/miniprogram-licia/hslToRgb.js new file mode 100644 index 0000000..52b448c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/hslToRgb.js @@ -0,0 +1,40 @@ +exports = function(hsl) { + var h = hsl[0] / 360; + var s = hsl[1] / 100; + var l = hsl[2] / 100; + var ret = []; + var t2; + var t3; + var val; + if (hsl[3]) ret[3] = hsl[3]; + if (s === 0) { + val = round(l * 255); + ret[0] = ret[1] = ret[2] = val; + return ret; + } + if (l < 0.5) { + t2 = l * (1 + s); + } else { + t2 = l + s - l * s; + } + var t1 = 2 * l - t2; + for (var i = 0; i < 3; i++) { + t3 = h + (1 / 3) * -(i - 1); + if (t3 < 0) t3++; + if (t3 > 1) t3--; + if (6 * t3 < 1) { + val = t1 + (t2 - t1) * 6 * t3; + } else if (2 * t3 < 1) { + val = t2; + } else if (3 * t3 < 2) { + val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; + } else { + val = t1; + } + ret[i] = round(val * 255); + } + return ret; +}; +var round = Math.round; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/html.js b/src/miniprogram_npm/miniprogram-licia/html.js new file mode 100644 index 0000000..95b334d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/html.js @@ -0,0 +1,84 @@ +var parseHtml = require('./parseHtml'); +var Stack = require('./Stack'); +var isArr = require('./isArr'); +var each = require('./each'); +var isStr = require('./isStr'); +var mapObj = require('./mapObj'); +function parse(html) { + var ret = []; + var stack = new Stack(); + parseHtml(html, { + start: function(tag, attrs) { + attrs = mapObj(attrs, function(val) { + return unescapeQuote(val); + }); + stack.push({ + tag: tag, + attrs: attrs + }); + }, + end: function() { + var node = stack.pop(); + if (!stack.size) { + ret.push(node); + return; + } + var lastNode = stack.peek(); + if (!isArr(lastNode.content)) { + lastNode.content = []; + } + lastNode.content.push(node); + }, + comment: function(text) { + var comment = ''); + var lastNode = stack.peek(); + if (!lastNode) { + ret.push(comment); + return; + } + if (!lastNode.content) lastNode.content = []; + lastNode.content.push(comment); + }, + text: function(text) { + var lastNode = stack.peek(); + if (!lastNode) { + ret.push(text); + return; + } + if (!lastNode.content) lastNode.content = []; + lastNode.content.push(text); + } + }); + return ret; +} +function stringify(tree) { + var ret = ''; + if (isArr(tree)) { + each(tree, function(node) { + return (ret += stringify(node)); + }); + } else if (isStr(tree)) { + ret = tree; + } else { + ret += '<'.concat(tree.tag); + each(tree.attrs, function(val, key) { + return (ret += ' '.concat(key, '="').concat(escapeQuote(val), '"')); + }); + ret += '>'; + if (tree.content) ret += stringify(tree.content); + ret += ''); + } + return ret; +} +var unescapeQuote = function(str) { + return str.replace(/"/g, '"'); +}; +var escapeQuote = function(str) { + return str.replace(/"/g, '"'); +}; +exports = { + parse: parse, + stringify: stringify +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/identity.js b/src/miniprogram_npm/miniprogram-licia/identity.js new file mode 100644 index 0000000..2566c33 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/identity.js @@ -0,0 +1,5 @@ +exports = function(val) { + return val; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/idxOf.js b/src/miniprogram_npm/miniprogram-licia/idxOf.js new file mode 100644 index 0000000..00dd41b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/idxOf.js @@ -0,0 +1,5 @@ +exports = function(arr, val, fromIdx) { + return Array.prototype.indexOf.call(arr, val, fromIdx); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/indent.js b/src/miniprogram_npm/miniprogram-licia/indent.js new file mode 100644 index 0000000..12be4f2 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/indent.js @@ -0,0 +1,16 @@ +var isNum = require('./isNum'); +var isUndef = require('./isUndef'); +var repeat = require('./repeat'); +var regLineBegin = /^(?!\s*$)/gm; +exports = function(str, char, len) { + if (isNum(char)) { + len = char; + char = ' '; + } + if (isUndef(len)) len = 4; + if (isUndef(char)) char = ' '; + char = repeat(char, len); + return str.replace(regLineBegin, char); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/index.js b/src/miniprogram_npm/miniprogram-licia/index.js new file mode 100644 index 0000000..38a192e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/index.js @@ -0,0 +1,359 @@ +exports.Benchmark = require('./Benchmark'); +exports.BloomFilter = require('./BloomFilter'); +exports.Caseless = require('./Caseless'); +exports.Channel = require('./Channel'); +exports.Class = require('./Class'); +exports.Color = require('./Color'); +exports.Delegator = require('./Delegator'); +exports.Dispatcher = require('./Dispatcher'); +exports.Emitter = require('./Emitter'); +exports.Enum = require('./Enum'); +exports.HashTable = require('./HashTable'); +exports.Heap = require('./Heap'); +exports.HeapSnapshot = require('./HeapSnapshot'); +exports.I18n = require('./I18n'); +exports.JsonTransformer = require('./JsonTransformer'); +exports.LinkedList = require('./LinkedList'); +exports.Logger = require('./Logger'); +exports.Lru = require('./Lru'); +exports.PriorityQueue = require('./PriorityQueue'); +exports.Promise = require('./Promise'); +exports.PseudoMap = require('./PseudoMap'); +exports.Queue = require('./Queue'); +exports.QuickLru = require('./QuickLru'); +exports.Readiness = require('./Readiness'); +exports.ReduceStore = require('./ReduceStore'); +exports.Semaphore = require('./Semaphore'); +exports.SingleEmitter = require('./SingleEmitter'); +exports.Stack = require('./Stack'); +exports.State = require('./State'); +exports.Store = require('./Store'); +exports.Trace = require('./Trace'); +exports.Tracing = require('./Tracing'); +exports.Trie = require('./Trie'); +exports.Tween = require('./Tween'); +exports.Url = require('./Url'); +exports.Validator = require('./Validator'); +exports.Wrr = require('./Wrr'); +exports.abbrev = require('./abbrev'); +exports.after = require('./after'); +exports.allKeys = require('./allKeys'); +exports.arrToMap = require('./arrToMap'); +exports.atob = require('./atob'); +exports.average = require('./average'); +exports.base64 = require('./base64'); +exports.before = require('./before'); +exports.binarySearch = require('./binarySearch'); +exports.bind = require('./bind'); +exports.btoa = require('./btoa'); +exports.bubbleSort = require('./bubbleSort'); +exports.bytesToStr = require('./bytesToStr'); +exports.bytesToWords = require('./bytesToWords'); +exports.callbackify = require('./callbackify'); +exports.camelCase = require('./camelCase'); +exports.capitalize = require('./capitalize'); +exports.castPath = require('./castPath'); +exports.centerAlign = require('./centerAlign'); +exports.char = require('./char'); +exports.chunk = require('./chunk'); +exports.clamp = require('./clamp'); +exports.className = require('./className'); +exports.clone = require('./clone'); +exports.cloneDeep = require('./cloneDeep'); +exports.cmpVersion = require('./cmpVersion'); +exports.combine = require('./combine'); +exports.compact = require('./compact'); +exports.compose = require('./compose'); +exports.concat = require('./concat'); +exports.contain = require('./contain'); +exports.convertBase = require('./convertBase'); +exports.convertBin = require('./convertBin'); +exports.crc1 = require('./crc1'); +exports.crc16 = require('./crc16'); +exports.crc32 = require('./crc32'); +exports.crc8 = require('./crc8'); +exports.create = require('./create'); +exports.createAssigner = require('./createAssigner'); +exports.css = require('./css'); +exports.cssPriority = require('./cssPriority'); +exports.curry = require('./curry'); +exports.dataUrl = require('./dataUrl'); +exports.dateFormat = require('./dateFormat'); +exports.debounce = require('./debounce'); +exports.deburr = require('./deburr'); +exports.decodeUriComponent = require('./decodeUriComponent'); +exports.defaults = require('./defaults'); +exports.define = require('./define'); +exports.defineProp = require('./defineProp'); +exports.defined = require('./defined'); +exports.delay = require('./delay'); +exports.deprecate = require('./deprecate'); +exports.detectBrowser = require('./detectBrowser'); +exports.detectMocha = require('./detectMocha'); +exports.detectOs = require('./detectOs'); +exports.difference = require('./difference'); +exports.dotCase = require('./dotCase'); +exports.durationFormat = require('./durationFormat'); +exports.each = require('./each'); +exports.easing = require('./easing'); +exports.endWith = require('./endWith'); +exports.escape = require('./escape'); +exports.escapeJsStr = require('./escapeJsStr'); +exports.escapeRegExp = require('./escapeRegExp'); +exports.every = require('./every'); +exports.extend = require('./extend'); +exports.extendDeep = require('./extendDeep'); +exports.extendOwn = require('./extendOwn'); +exports.extractBlockCmts = require('./extractBlockCmts'); +exports.extractUrls = require('./extractUrls'); +exports.fibonacci = require('./fibonacci'); +exports.fileSize = require('./fileSize'); +exports.fileType = require('./fileType'); +exports.fileUrl = require('./fileUrl'); +exports.fill = require('./fill'); +exports.filter = require('./filter'); +exports.find = require('./find'); +exports.findIdx = require('./findIdx'); +exports.findKey = require('./findKey'); +exports.findLastIdx = require('./findLastIdx'); +exports.flatten = require('./flatten'); +exports.fnArgs = require('./fnArgs'); +exports.fnParams = require('./fnParams'); +exports.fnv1a = require('./fnv1a'); +exports.format = require('./format'); +exports.fraction = require('./fraction'); +exports.freeze = require('./freeze'); +exports.freezeDeep = require('./freezeDeep'); +exports.fuzzySearch = require('./fuzzySearch'); +exports.gcd = require('./gcd'); +exports.getProto = require('./getProto'); +exports.getUrlParam = require('./getUrlParam'); +exports.golangify = require('./golangify'); +exports.has = require('./has'); +exports.heapSort = require('./heapSort'); +exports.hex = require('./hex'); +exports.highlight = require('./highlight'); +exports.hookFn = require('./hookFn'); +exports.hslToRgb = require('./hslToRgb'); +exports.html = require('./html'); +exports.identity = require('./identity'); +exports.idxOf = require('./idxOf'); +exports.indent = require('./indent'); +exports.inherits = require('./inherits'); +exports.ini = require('./ini'); +exports.insertionSort = require('./insertionSort'); +exports.intersect = require('./intersect'); +exports.intersectRange = require('./intersectRange'); +exports.invariant = require('./invariant'); +exports.invert = require('./invert'); +exports.isAbsoluteUrl = require('./isAbsoluteUrl'); +exports.isArgs = require('./isArgs'); +exports.isArr = require('./isArr'); +exports.isArrBuffer = require('./isArrBuffer'); +exports.isArrLike = require('./isArrLike'); +exports.isAsyncFn = require('./isAsyncFn'); +exports.isBool = require('./isBool'); +exports.isBrowser = require('./isBrowser'); +exports.isBuffer = require('./isBuffer'); +exports.isClose = require('./isClose'); +exports.isCyclic = require('./isCyclic'); +exports.isDataUrl = require('./isDataUrl'); +exports.isDate = require('./isDate'); +exports.isEmail = require('./isEmail'); +exports.isEmpty = require('./isEmpty'); +exports.isEqual = require('./isEqual'); +exports.isErr = require('./isErr'); +exports.isEven = require('./isEven'); +exports.isFinite = require('./isFinite'); +exports.isFn = require('./isFn'); +exports.isFullWidth = require('./isFullWidth'); +exports.isGeneratorFn = require('./isGeneratorFn'); +exports.isInt = require('./isInt'); +exports.isIp = require('./isIp'); +exports.isJson = require('./isJson'); +exports.isLeapYear = require('./isLeapYear'); +exports.isMac = require('./isMac'); +exports.isMap = require('./isMap'); +exports.isMatch = require('./isMatch'); +exports.isMiniProgram = require('./isMiniProgram'); +exports.isMobile = require('./isMobile'); +exports.isNaN = require('./isNaN'); +exports.isNative = require('./isNative'); +exports.isNil = require('./isNil'); +exports.isNode = require('./isNode'); +exports.isNull = require('./isNull'); +exports.isNum = require('./isNum'); +exports.isNumeric = require('./isNumeric'); +exports.isObj = require('./isObj'); +exports.isOdd = require('./isOdd'); +exports.isPlainObj = require('./isPlainObj'); +exports.isPrime = require('./isPrime'); +exports.isPrimitive = require('./isPrimitive'); +exports.isPromise = require('./isPromise'); +exports.isRegExp = require('./isRegExp'); +exports.isRelative = require('./isRelative'); +exports.isSet = require('./isSet'); +exports.isSorted = require('./isSorted'); +exports.isStr = require('./isStr'); +exports.isStrBlank = require('./isStrBlank'); +exports.isSymbol = require('./isSymbol'); +exports.isTypedArr = require('./isTypedArr'); +exports.isUndef = require('./isUndef'); +exports.isUrl = require('./isUrl'); +exports.isWeakMap = require('./isWeakMap'); +exports.isWeakSet = require('./isWeakSet'); +exports.isWindows = require('./isWindows'); +exports.jsonClone = require('./jsonClone'); +exports.kebabCase = require('./kebabCase'); +exports.keyCode = require('./keyCode'); +exports.keys = require('./keys'); +exports.last = require('./last'); +exports.levenshtein = require('./levenshtein'); +exports.linkify = require('./linkify'); +exports.longest = require('./longest'); +exports.lowerCase = require('./lowerCase'); +exports.lpad = require('./lpad'); +exports.ltrim = require('./ltrim'); +exports.map = require('./map'); +exports.mapObj = require('./mapObj'); +exports.matcher = require('./matcher'); +exports.max = require('./max'); +exports.md5 = require('./md5'); +exports.memStorage = require('./memStorage'); +exports.memoize = require('./memoize'); +exports.mergeArr = require('./mergeArr'); +exports.mergeSort = require('./mergeSort'); +exports.methods = require('./methods'); +exports.mime = require('./mime'); +exports.min = require('./min'); +exports.moment = require('./moment'); +exports.morse = require('./morse'); +exports.ms = require('./ms'); +exports.naturalSort = require('./naturalSort'); +exports.negate = require('./negate'); +exports.nextTick = require('./nextTick'); +exports.noop = require('./noop'); +exports.normalizeHeader = require('./normalizeHeader'); +exports.normalizePath = require('./normalizePath'); +exports.normalizePhone = require('./normalizePhone'); +exports.now = require('./now'); +exports.objToStr = require('./objToStr'); +exports.omit = require('./omit'); +exports.once = require('./once'); +exports.optimizeCb = require('./optimizeCb'); +exports.ordinal = require('./ordinal'); +exports.pad = require('./pad'); +exports.pairs = require('./pairs'); +exports.parallel = require('./parallel'); +exports.parseArgs = require('./parseArgs'); +exports.parseHtml = require('./parseHtml'); +exports.partial = require('./partial'); +exports.pascalCase = require('./pascalCase'); +exports.perfNow = require('./perfNow'); +exports.pick = require('./pick'); +exports.pluck = require('./pluck'); +exports.precision = require('./precision'); +exports.promisify = require('./promisify'); +exports.property = require('./property'); +exports.query = require('./query'); +exports.quickSort = require('./quickSort'); +exports.raf = require('./raf'); +exports.random = require('./random'); +exports.randomBytes = require('./randomBytes'); +exports.randomColor = require('./randomColor'); +exports.randomId = require('./randomId'); +exports.randomItem = require('./randomItem'); +exports.range = require('./range'); +exports.rc4 = require('./rc4'); +exports.reduce = require('./reduce'); +exports.reduceRight = require('./reduceRight'); +exports.reject = require('./reject'); +exports.remove = require('./remove'); +exports.repeat = require('./repeat'); +exports.replaceAll = require('./replaceAll'); +exports.restArgs = require('./restArgs'); +exports.reverse = require('./reverse'); +exports.rgbToHsl = require('./rgbToHsl'); +exports.root = require('./root'); +exports.rpad = require('./rpad'); +exports.rtrim = require('./rtrim'); +exports.safeCb = require('./safeCb'); +exports.safeDel = require('./safeDel'); +exports.safeGet = require('./safeGet'); +exports.safeSet = require('./safeSet'); +exports.sameOrigin = require('./sameOrigin'); +exports.sample = require('./sample'); +exports.seedRandom = require('./seedRandom'); +exports.selectionSort = require('./selectionSort'); +exports.selector = require('./selector'); +exports.shebang = require('./shebang'); +exports.shellSort = require('./shellSort'); +exports.shuffle = require('./shuffle'); +exports.size = require('./size'); +exports.sizeof = require('./sizeof'); +exports.sleep = require('./sleep'); +exports.slice = require('./slice'); +exports.slugify = require('./slugify'); +exports.snakeCase = require('./snakeCase'); +exports.some = require('./some'); +exports.sortBy = require('./sortBy'); +exports.sortKeys = require('./sortKeys'); +exports.spaceCase = require('./spaceCase'); +exports.splitCase = require('./splitCase'); +exports.splitPath = require('./splitPath'); +exports.startWith = require('./startWith'); +exports.strHash = require('./strHash'); +exports.strToBytes = require('./strToBytes'); +exports.strTpl = require('./strTpl'); +exports.strWidth = require('./strWidth'); +exports.stringify = require('./stringify'); +exports.stringifyAll = require('./stringifyAll'); +exports.stripAnsi = require('./stripAnsi'); +exports.stripBom = require('./stripBom'); +exports.stripCmt = require('./stripCmt'); +exports.stripColor = require('./stripColor'); +exports.stripHtmlTag = require('./stripHtmlTag'); +exports.stripIndent = require('./stripIndent'); +exports.stripNum = require('./stripNum'); +exports.sum = require('./sum'); +exports.swap = require('./swap'); +exports.table = require('./table'); +exports.throttle = require('./throttle'); +exports.timeAgo = require('./timeAgo'); +exports.timeTaken = require('./timeTaken'); +exports.times = require('./times'); +exports.toArr = require('./toArr'); +exports.toAsync = require('./toAsync'); +exports.toBool = require('./toBool'); +exports.toDate = require('./toDate'); +exports.toInt = require('./toInt'); +exports.toNum = require('./toNum'); +exports.toSrc = require('./toSrc'); +exports.toStr = require('./toStr'); +exports.topoSort = require('./topoSort'); +exports.trim = require('./trim'); +exports.truncate = require('./truncate'); +exports.tryIt = require('./tryIt'); +exports.type = require('./type'); +exports.types = require('./types'); +exports.ucs2 = require('./ucs2'); +exports.unescape = require('./unescape'); +exports.union = require('./union'); +exports.uniqId = require('./uniqId'); +exports.unique = require('./unique'); +exports.universalify = require('./universalify'); +exports.unzip = require('./unzip'); +exports.upperCase = require('./upperCase'); +exports.upperFirst = require('./upperFirst'); +exports.use = require('./use'); +exports.utf8 = require('./utf8'); +exports.uuid = require('./uuid'); +exports.values = require('./values'); +exports.vlq = require('./vlq'); +exports.waitUntil = require('./waitUntil'); +exports.waterfall = require('./waterfall'); +exports.wordWrap = require('./wordWrap'); +exports.wordsToBytes = require('./wordsToBytes'); +exports.wrap = require('./wrap'); +exports.wx = require('./wx'); +exports.zip = require('./zip'); diff --git a/src/miniprogram_npm/miniprogram-licia/inherits.js b/src/miniprogram_npm/miniprogram-licia/inherits.js new file mode 100644 index 0000000..e1e7e22 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/inherits.js @@ -0,0 +1,6 @@ +var create = require('./create'); +exports = function(Class, SuperClass) { + Class.prototype = create(SuperClass.prototype); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/ini.js b/src/miniprogram_npm/miniprogram-licia/ini.js new file mode 100644 index 0000000..13334b3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/ini.js @@ -0,0 +1,90 @@ +var each = require('./each'); +var trim = require('./trim'); +var safeSet = require('./safeSet'); +var safeGet = require('./safeGet'); +var endWith = require('./endWith'); +var isArr = require('./isArr'); +var isObj = require('./isObj'); + +var regSection = /^\[([^\]]*)\]$/i; +var regKeyVal = /^([^=]+)(=(.*))?$/i; +var regComment = /^\s*[;#]/; +function parse(ini) { + var ret = {}; + var section = ret; + each(ini.split('\n'), function(line) { + line = trim(line); + if (!line || line.match(regComment)) return; + var match = line.match(regSection); + if (match && match[1]) { + var _key = match[1]; + section = safeGet(ret, _key) || {}; + return safeSet(ret, _key, section); + } + match = line.match(regKeyVal); + if (!match) return; + var key = trim(match[1]); + var val = match[2] ? trim(match[3]) : true; + if (val === 'true') val = true; + if (val === 'false') val = false; + if (val === 'null') val = null; + if (endWith(key, '[]')) { + key = key.substring(0, key.length - 2); + if (!section[key]) section[key] = []; + } + isArr(section[key]) ? section[key].push(val) : (section[key] = val); + }); + return ret; +} +function stringify(obj) { + var options = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var ret = ''; + var section = options.section; + var whitespace = options.whitespace; + var separator = whitespace ? ' = ' : '='; + var children = []; + each(obj, function(val, key) { + if (isArr(val)) { + each(val, function(item) { + ret += '' + .concat(key, '[]') + .concat(separator) + .concat(item, '\n'); + }); + } else if (isObj(val)) { + children.push({ + key: key, + val: val + }); + } else { + ret += '' + .concat(key) + .concat(separator) + .concat(val, '\n'); + } + }); + if (section && ret) { + ret = '['.concat(section, ']\n') + ret; + } + section = section ? section + '.' : ''; + each(children, function(child) { + child = stringify(child.val, { + section: section + child.key, + whitespace: options.whitespace + }); + if (child) { + if (ret) { + ret += '\n'; + } + ret += child; + } + }); + return ret; +} +exports = { + parse: parse, + stringify: stringify +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/insertionSort.js b/src/miniprogram_npm/miniprogram-licia/insertionSort.js new file mode 100644 index 0000000..c3ad7ab --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/insertionSort.js @@ -0,0 +1,20 @@ +var swap = require('./swap'); +var isSorted = require('./isSorted'); +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : isSorted.defComparator; + for (var i = 1, len = arr.length; i < len; i++) { + for (var j = i; j > 0; j--) { + if (cmp(arr[j], arr[j - 1]) < 0) { + swap(arr, j, j - 1); + } else { + break; + } + } + } + return arr; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/intersect.js b/src/miniprogram_npm/miniprogram-licia/intersect.js new file mode 100644 index 0000000..d6d6ffc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/intersect.js @@ -0,0 +1,19 @@ +var contain = require('./contain'); +var toArr = require('./toArr'); +exports = function(arr) { + var ret = []; + var args = toArr(arguments); + var argsLen = args.length; + for (var i = 0, len = arr.length; i < len; i++) { + var item = arr[i]; + if (contain(ret, item)) continue; + var j = 1; + for (; j < argsLen; j++) { + if (!contain(args[j], item)) break; + } + if (j === argsLen) ret.push(item); + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/intersectRange.js b/src/miniprogram_npm/miniprogram-licia/intersectRange.js new file mode 100644 index 0000000..7875991 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/intersectRange.js @@ -0,0 +1,11 @@ +exports = function(a, b) { + var min = a.start < b.start ? a : b; + var max = min === a ? b : a; + if (min.end < max.start) return; + return { + start: max.start, + end: min.end < max.end ? min.end : max.end + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/invariant.js b/src/miniprogram_npm/miniprogram-licia/invariant.js new file mode 100644 index 0000000..30c4c05 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/invariant.js @@ -0,0 +1,35 @@ +var root = require('./root'); +exports = function(condition, format, a, b, c, d, e, f) { + var process = root.process || { + env: { + NODE_ENV: 'development' + } + }; + if (process.env.NODE_ENV !== 'production') { + if (format === undefined) { + throw new Error('invariant requires an error message argument'); + } + } + if (!condition) { + var error; + if (format === undefined) { + error = new Error( + 'Minified exception occurred; use the non-minified dev environment ' + + 'for the full error message and additional helpful warnings.' + ); + } else { + var args = [a, b, c, d, e, f]; + var argIndex = 0; + error = new Error( + format.replace(/%s/g, function() { + return args[argIndex++]; + }) + ); + error.name = 'Invariant Violation'; + } + error.framesToPop = 1; + throw error; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/invert.js b/src/miniprogram_npm/miniprogram-licia/invert.js new file mode 100644 index 0000000..1ec52f1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/invert.js @@ -0,0 +1,10 @@ +var each = require('./each'); +exports = function(obj) { + var ret = {}; + each(obj, function(val, key) { + ret[val] = key; + }); + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isAbsoluteUrl.js b/src/miniprogram_npm/miniprogram-licia/isAbsoluteUrl.js new file mode 100644 index 0000000..a465c78 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isAbsoluteUrl.js @@ -0,0 +1,6 @@ +exports = function(url) { + return regAbsolute.test(url); +}; +var regAbsolute = /^[a-z][a-z0-9+.-]*:/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isArgs.js b/src/miniprogram_npm/miniprogram-licia/isArgs.js new file mode 100644 index 0000000..36d8830 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isArgs.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object Arguments]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isArr.js b/src/miniprogram_npm/miniprogram-licia/isArr.js new file mode 100644 index 0000000..2c07ff3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isArr.js @@ -0,0 +1,10 @@ +var objToStr = require('./objToStr'); +if (Array.isArray && !false) { + exports = Array.isArray; +} else { + exports = function(val) { + return objToStr(val) === '[object Array]'; + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isArrBuffer.js b/src/miniprogram_npm/miniprogram-licia/isArrBuffer.js new file mode 100644 index 0000000..20d8fcf --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isArrBuffer.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object ArrayBuffer]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isArrLike.js b/src/miniprogram_npm/miniprogram-licia/isArrLike.js new file mode 100644 index 0000000..6394dca --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isArrLike.js @@ -0,0 +1,10 @@ +var isNum = require('./isNum'); +var isFn = require('./isFn'); +var MAX_ARR_IDX = Math.pow(2, 53) - 1; +exports = function(val) { + if (!val) return false; + var len = val.length; + return isNum(len) && len >= 0 && len <= MAX_ARR_IDX && !isFn(val); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isAsyncFn.js b/src/miniprogram_npm/miniprogram-licia/isAsyncFn.js new file mode 100644 index 0000000..115411a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isAsyncFn.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object AsyncFunction]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isBool.js b/src/miniprogram_npm/miniprogram-licia/isBool.js new file mode 100644 index 0000000..022b906 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isBool.js @@ -0,0 +1,5 @@ +exports = function(val) { + return val === true || val === false; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isBrowser.js b/src/miniprogram_npm/miniprogram-licia/isBrowser.js new file mode 100644 index 0000000..5f7fa60 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isBrowser.js @@ -0,0 +1,6 @@ +exports = + typeof window === 'object' && + typeof document === 'object' && + document.nodeType === 9; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isBuffer.js b/src/miniprogram_npm/miniprogram-licia/isBuffer.js new file mode 100644 index 0000000..9c7d3c7 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isBuffer.js @@ -0,0 +1,12 @@ +var isFn = require('./isFn'); +exports = function(val) { + if (val == null) return false; + if (val._isBuffer) return true; + return ( + val.constructor && + isFn(val.constructor.isBuffer) && + val.constructor.isBuffer(val) + ); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isClose.js b/src/miniprogram_npm/miniprogram-licia/isClose.js new file mode 100644 index 0000000..0ebabaa --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isClose.js @@ -0,0 +1,10 @@ +var isNum = require('./isNum'); +exports = function(a, b, relTol, absTol) { + if (!isNum(relTol)) relTol = 1e-9; + if (!isNum(absTol)) absTol = 0; + return abs(a - b) <= max(relTol * max(abs(a), abs(b)), absTol); +}; +var abs = Math.abs; +var max = Math.max; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isCyclic.js b/src/miniprogram_npm/miniprogram-licia/isCyclic.js new file mode 100644 index 0000000..7dc324d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isCyclic.js @@ -0,0 +1,38 @@ +var Class = require('./Class'); +var keys = require('./keys'); +var isObj = require('./isObj'); +exports = function(val, parents) { + if (!isObj(val)) { + return false; + } + if (parents && parents.contains(val)) { + return true; + } + parents = new Node(val, parents); + var _keys = keys(val); + for (var i = 0, len = _keys.length; i < len; i++) { + if (exports(val[_keys[i]], parents)) { + return true; + } + } + return false; +}; + +var Node = Class({ + initialize: function Node(val, next) { + this.val = val; + this.next = next; + }, + contains: function(val) { + var cursor = this; + while (cursor) { + if (cursor.val === val) { + return true; + } + cursor = cursor.next; + } + return false; + } +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isDataUrl.js b/src/miniprogram_npm/miniprogram-licia/isDataUrl.js new file mode 100644 index 0000000..6ceeacc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isDataUrl.js @@ -0,0 +1,8 @@ +var trim = require('./trim'); +exports = function(str) { + return regDataUrl.test(trim(str)); +}; + +var regDataUrl = /^data:([a-z]+\/[a-z0-9-+.]+(;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}|~`]+)*)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@/?%\s]*?)$/i; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isDate.js b/src/miniprogram_npm/miniprogram-licia/isDate.js new file mode 100644 index 0000000..54dc0df --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isDate.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object Date]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isEmail.js b/src/miniprogram_npm/miniprogram-licia/isEmail.js new file mode 100644 index 0000000..34155c8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isEmail.js @@ -0,0 +1,6 @@ +exports = function(val) { + return regEmail.test(val); +}; +var regEmail = /.+@.+\..+/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isEmpty.js b/src/miniprogram_npm/miniprogram-licia/isEmpty.js new file mode 100644 index 0000000..f37c6a6 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isEmpty.js @@ -0,0 +1,14 @@ +var isArrLike = require('./isArrLike'); +var isArr = require('./isArr'); +var isStr = require('./isStr'); +var isArgs = require('./isArgs'); +var keys = require('./keys'); +exports = function(val) { + if (val == null) return true; + if (isArrLike(val) && (isArr(val) || isStr(val) || isArgs(val))) { + return val.length === 0; + } + return keys(val).length === 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isEqual.js b/src/miniprogram_npm/miniprogram-licia/isEqual.js new file mode 100644 index 0000000..fbb4bb8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isEqual.js @@ -0,0 +1,75 @@ +var isFn = require('./isFn'); +var has = require('./has'); +var keys = require('./keys'); +exports = function(a, b) { + return eq(a, b); +}; +function deepEq(a, b, aStack, bStack) { + var className = toString.call(a); + if (className !== toString.call(b)) return false; + switch (className) { + case '[object RegExp]': + case '[object String]': + return '' + a === '' + b; + case '[object Number]': + if (+a !== +a) return +b !== +b; + return +a === 0 ? 1 / +a === 1 / b : +a === +b; + case '[object Date]': + case '[object Boolean]': + return +a === +b; + } + var areArrays = className === '[object Array]'; + if (!areArrays) { + if (typeof a != 'object' || typeof b != 'object') return false; + var aCtor = a.constructor; + var bCtor = b.constructor; + if ( + aCtor !== bCtor && + !( + isFn(aCtor) && + aCtor instanceof aCtor && + isFn(bCtor) && + bCtor instanceof bCtor + ) && + 'constructor' in a && + 'constructor' in b + ) + return false; + } + aStack = aStack || []; + bStack = bStack || []; + var length = aStack.length; + while (length--) if (aStack[length] === a) return bStack[length] === b; + aStack.push(a); + bStack.push(b); + if (areArrays) { + length = a.length; + if (length !== b.length) return false; + while (length--) + if (!eq(a[length], b[length], aStack, bStack)) return false; + } else { + var _keys = keys(a); + var key; + length = _keys.length; + if (keys(b).length !== length) return false; + while (length--) { + key = _keys[length]; + if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) + return false; + } + } + aStack.pop(); + bStack.pop(); + return true; +} +function eq(a, b, aStack, bStack) { + if (a === b) return a !== 0 || 1 / a === 1 / b; + if (a == null || b == null) return a === b; + if (a !== a) return b !== b; + var type = typeof a; + if (type !== 'function' && type !== 'object' && typeof b != 'object') + return false; + return deepEq(a, b, aStack, bStack); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isErr.js b/src/miniprogram_npm/miniprogram-licia/isErr.js new file mode 100644 index 0000000..ec27962 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isErr.js @@ -0,0 +1,12 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + switch (objToStr(val)) { + case '[object Error]': + case '[object DOMException]': + return true; + default: + return val instanceof Error; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isEven.js b/src/miniprogram_npm/miniprogram-licia/isEven.js new file mode 100644 index 0000000..daf74e4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isEven.js @@ -0,0 +1,7 @@ +var isInt = require('./isInt'); +exports = function(num) { + if (!isInt(num)) return false; + return num % 2 === 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isFinite.js b/src/miniprogram_npm/miniprogram-licia/isFinite.js new file mode 100644 index 0000000..f4577e3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isFinite.js @@ -0,0 +1,8 @@ +var root = require('./root'); +var nativeIsFinite = root.isFinite; +var nativeIsNaN = root.isNaN; +exports = function(val) { + return nativeIsFinite(val) && !nativeIsNaN(parseFloat(val)); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isFn.js b/src/miniprogram_npm/miniprogram-licia/isFn.js new file mode 100644 index 0000000..e291951 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isFn.js @@ -0,0 +1,11 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + var objStr = objToStr(val); + return ( + objStr === '[object Function]' || + objStr === '[object GeneratorFunction]' || + objStr === '[object AsyncFunction]' + ); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isFullWidth.js b/src/miniprogram_npm/miniprogram-licia/isFullWidth.js new file mode 100644 index 0000000..b7bf290 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isFullWidth.js @@ -0,0 +1,29 @@ +var isInt = require('./isInt'); + +exports = function isFullWidth(c) { + if (!isInt(c)) { + return false; + } + + return ( + c >= 0x1100 && + (c <= 0x115f || + c === 0x2329 || + c === 0x232a || + (0x2e80 <= c && c <= 0x3247 && c !== 0x303f) || + (0x3250 <= c && c <= 0x4dbf) || + (0x4e00 <= c && c <= 0xa4c6) || + (0xa960 <= c && c <= 0xa97c) || + (0xac00 <= c && c <= 0xd7a3) || + (0xf900 <= c && c <= 0xfaff) || + (0xfe10 <= c && c <= 0xfe19) || + (0xfe30 <= c && c <= 0xfe6b) || + (0xff01 <= c && c <= 0xff60) || + (0xffe0 <= c && c <= 0xffe6) || + (0x1b000 <= c && c <= 0x1b001) || + (0x1f200 <= c && c <= 0x1f251) || + (0x20000 <= c && c <= 0x3fffd)) + ); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isGeneratorFn.js b/src/miniprogram_npm/miniprogram-licia/isGeneratorFn.js new file mode 100644 index 0000000..e4fddc5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isGeneratorFn.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object GeneratorFunction]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isInt.js b/src/miniprogram_npm/miniprogram-licia/isInt.js new file mode 100644 index 0000000..07d46b1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isInt.js @@ -0,0 +1,6 @@ +var isNum = require('./isNum'); +exports = function(val) { + return isNum(val) && val % 1 === 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isIp.js b/src/miniprogram_npm/miniprogram-licia/isIp.js new file mode 100644 index 0000000..050f132 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isIp.js @@ -0,0 +1,54 @@ +exports = function(str) { + return exports.v4(str) || exports.v6(str); +}; + +var v4 = + '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}'; +var regV4 = new RegExp('^'.concat(v4, '$')); +var v6seg = '[a-fA-F\\d]{1,4}'; +var v6 = [ + '(', + '(?:'.concat(v6seg, ':){7}(?:').concat(v6seg, '|:)|'), + '(?:' + .concat(v6seg, ':){6}(?:') + .concat(v4, '|:') + .concat(v6seg, '|:)|'), + '(?:' + .concat(v6seg, ':){5}(?::') + .concat(v4, '|(:') + .concat(v6seg, '){1,2}|:)|'), + '(?:' + .concat(v6seg, ':){4}(?:(:') + .concat(v6seg, '){0,1}:') + .concat(v4, '|(:') + .concat(v6seg, '){1,3}|:)|'), + '(?:' + .concat(v6seg, ':){3}(?:(:') + .concat(v6seg, '){0,2}:') + .concat(v4, '|(:') + .concat(v6seg, '){1,4}|:)|'), + '(?:' + .concat(v6seg, ':){2}(?:(:') + .concat(v6seg, '){0,3}:') + .concat(v4, '|(:') + .concat(v6seg, '){1,5}|:)|'), + '(?:' + .concat(v6seg, ':){1}(?:(:') + .concat(v6seg, '){0,4}:') + .concat(v4, '|(:') + .concat(v6seg, '){1,6}|:)|'), + '(?::((?::' + .concat(v6seg, '){0,5}:') + .concat(v4, '|(?::') + .concat(v6seg, '){1,7}|:))'), + ')(%[0-9a-zA-Z]{1,})?' +].join(''); +var regV6 = new RegExp('^'.concat(v6, '$')); +exports.v4 = function(str) { + return regV4.test(str); +}; +exports.v6 = function(str) { + return regV6.test(str); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isJson.js b/src/miniprogram_npm/miniprogram-licia/isJson.js new file mode 100644 index 0000000..8245c82 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isJson.js @@ -0,0 +1,10 @@ +exports = function(val) { + try { + JSON.parse(val); + return true; + } catch (e) { + return false; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isLeapYear.js b/src/miniprogram_npm/miniprogram-licia/isLeapYear.js new file mode 100644 index 0000000..4c6b4cb --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isLeapYear.js @@ -0,0 +1,5 @@ +exports = function(year) { + return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isMac.js b/src/miniprogram_npm/miniprogram-licia/isMac.js new file mode 100644 index 0000000..72fbd9d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isMac.js @@ -0,0 +1,4 @@ +var detectOs = require('./detectOs'); +exports = detectOs() === 'os x'; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isMap.js b/src/miniprogram_npm/miniprogram-licia/isMap.js new file mode 100644 index 0000000..ffbbfa3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isMap.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object Map]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isMatch.js b/src/miniprogram_npm/miniprogram-licia/isMatch.js new file mode 100644 index 0000000..98fc236 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isMatch.js @@ -0,0 +1,14 @@ +var keys = require('./keys'); +exports = function(obj, src) { + var _keys = keys(src); + var len = _keys.length; + if (obj == null) return !len; + obj = Object(obj); + for (var i = 0; i < len; i++) { + var key = _keys[i]; + if (src[key] !== obj[key] || !(key in obj)) return false; + } + return true; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isMiniProgram.js b/src/miniprogram_npm/miniprogram-licia/isMiniProgram.js new file mode 100644 index 0000000..1589806 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isMiniProgram.js @@ -0,0 +1,5 @@ +var isFn = require('./isFn'); + +exports = typeof wx !== 'undefined' && isFn(wx.openLocation); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isMobile.js b/src/miniprogram_npm/miniprogram-licia/isMobile.js new file mode 100644 index 0000000..6c0a212 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isMobile.js @@ -0,0 +1,10 @@ +var isBrowser = require('./isBrowser'); +var memoize = require('./memoize'); +var regMobileAll = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i; +var regMobileFour = /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i; +exports = memoize(function(ua) { + ua = ua || (isBrowser ? navigator.userAgent : ''); + return regMobileAll.test(ua) || regMobileFour.test(ua.substr(0, 4)); +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isNaN.js b/src/miniprogram_npm/miniprogram-licia/isNaN.js new file mode 100644 index 0000000..176d9a3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isNaN.js @@ -0,0 +1,6 @@ +var isNum = require('./isNum'); +exports = function(val) { + return isNum(val) && val !== +val; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isNative.js b/src/miniprogram_npm/miniprogram-licia/isNative.js new file mode 100644 index 0000000..9b02b85 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isNative.js @@ -0,0 +1,23 @@ +var isObj = require('./isObj'); +var isFn = require('./isFn'); +var toSrc = require('./toSrc'); +exports = function(val) { + if (!isObj(val)) return false; + if (isFn(val)) return regIsNative.test(toSrc(val)); + + return regIsHostCtor.test(toSrc(val)); +}; +var hasOwnProperty = Object.prototype.hasOwnProperty; +var regIsNative = new RegExp( + '^' + + toSrc(hasOwnProperty) + .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&') + .replace( + /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, + '$1.*?' + ) + + '$' +); +var regIsHostCtor = /^\[object .+?Constructor\]$/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isNil.js b/src/miniprogram_npm/miniprogram-licia/isNil.js new file mode 100644 index 0000000..2a7de9a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isNil.js @@ -0,0 +1,5 @@ +exports = function(val) { + return val == null; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isNode.js b/src/miniprogram_npm/miniprogram-licia/isNode.js new file mode 100644 index 0000000..559584e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isNode.js @@ -0,0 +1,5 @@ +var objToStr = require('./objToStr'); +exports = + typeof process !== 'undefined' && objToStr(process) === '[object process]'; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isNull.js b/src/miniprogram_npm/miniprogram-licia/isNull.js new file mode 100644 index 0000000..82b8b08 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isNull.js @@ -0,0 +1,5 @@ +exports = function(val) { + return val === null; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isNum.js b/src/miniprogram_npm/miniprogram-licia/isNum.js new file mode 100644 index 0000000..43ef931 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isNum.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object Number]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isNumeric.js b/src/miniprogram_npm/miniprogram-licia/isNumeric.js new file mode 100644 index 0000000..9743bc3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isNumeric.js @@ -0,0 +1,11 @@ +var isStr = require('./isStr'); +var isNaN = require('./isNaN'); +var isFinite = require('./isFinite'); +var isArr = require('./isArr'); +exports = function(val) { + if (isStr(val)) val = val.replace(regComma, ''); + return !isNaN(parseFloat(val)) && isFinite(val) && !isArr(val); +}; +var regComma = /,/g; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isObj.js b/src/miniprogram_npm/miniprogram-licia/isObj.js new file mode 100644 index 0000000..1a0fdd2 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isObj.js @@ -0,0 +1,6 @@ +exports = function(val) { + var type = typeof val; + return !!val && (type === 'function' || type === 'object'); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isOdd.js b/src/miniprogram_npm/miniprogram-licia/isOdd.js new file mode 100644 index 0000000..7d65dcf --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isOdd.js @@ -0,0 +1,7 @@ +var isInt = require('./isInt'); +exports = function(num) { + if (!isInt(num)) return false; + return num % 2 !== 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isPlainObj.js b/src/miniprogram_npm/miniprogram-licia/isPlainObj.js new file mode 100644 index 0000000..77dca83 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isPlainObj.js @@ -0,0 +1,13 @@ +var isObj = require('./isObj'); +var isArr = require('./isArr'); +var isFn = require('./isFn'); +var has = require('./has'); +exports = function(val) { + if (!isObj(val)) return false; + var ctor = val.constructor; + if (!isFn(ctor)) return false; + if (!has(ctor.prototype, 'isPrototypeOf')) return false; + return !isArr(val) && !isFn(val); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isPrime.js b/src/miniprogram_npm/miniprogram-licia/isPrime.js new file mode 100644 index 0000000..af6a498 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isPrime.js @@ -0,0 +1,11 @@ +exports = function(num) { + var boundary = Math.floor(Math.sqrt(num)); + for (var i = 2; i <= boundary; i++) { + if (num % i === 0) { + return false; + } + } + return num >= 2; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isPrimitive.js b/src/miniprogram_npm/miniprogram-licia/isPrimitive.js new file mode 100644 index 0000000..1533ba9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isPrimitive.js @@ -0,0 +1,6 @@ +exports = function(val) { + var type = typeof val; + return val == null || (type !== 'function' && type !== 'object'); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isPromise.js b/src/miniprogram_npm/miniprogram-licia/isPromise.js new file mode 100644 index 0000000..c905b0b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isPromise.js @@ -0,0 +1,7 @@ +var isObj = require('./isObj'); +var isFn = require('./isFn'); +exports = function(val) { + return isObj(val) && isFn(val.then) && isFn(val.catch); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isRegExp.js b/src/miniprogram_npm/miniprogram-licia/isRegExp.js new file mode 100644 index 0000000..43708a2 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isRegExp.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object RegExp]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isRelative.js b/src/miniprogram_npm/miniprogram-licia/isRelative.js new file mode 100644 index 0000000..8dc14ef --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isRelative.js @@ -0,0 +1,6 @@ +exports = function(path) { + return !regAbsolute.test(path); +}; +var regAbsolute = /^([a-z]+:)?[\\/]/i; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isSet.js b/src/miniprogram_npm/miniprogram-licia/isSet.js new file mode 100644 index 0000000..95c5405 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isSet.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object Set]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isSorted.js b/src/miniprogram_npm/miniprogram-licia/isSorted.js new file mode 100644 index 0000000..9d76d42 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isSorted.js @@ -0,0 +1,17 @@ +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : exports.defComparator; + for (var i = 0, len = arr.length; i < len - 1; i++) { + if (cmp(arr[i], arr[i + 1]) > 0) return false; + } + return true; +}; +exports.defComparator = function(a, b) { + if (a < b) return -1; + if (a > b) return 1; + return 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isStr.js b/src/miniprogram_npm/miniprogram-licia/isStr.js new file mode 100644 index 0000000..496ae85 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isStr.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object String]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isStrBlank.js b/src/miniprogram_npm/miniprogram-licia/isStrBlank.js new file mode 100644 index 0000000..5b5f07c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isStrBlank.js @@ -0,0 +1,18 @@ +exports = function(str) { + for (var i = 0, len = str.length; i < len; i++) { + var c = str[i]; + if ( + c !== ' ' && + c !== '\n' && + c !== '\r' && + c !== '\t' && + c !== '\f' && + c !== '\v' + ) { + return false; + } + } + return true; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isSymbol.js b/src/miniprogram_npm/miniprogram-licia/isSymbol.js new file mode 100644 index 0000000..4237958 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isSymbol.js @@ -0,0 +1,5 @@ +exports = function(val) { + return typeof val === 'symbol'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isTypedArr.js b/src/miniprogram_npm/miniprogram-licia/isTypedArr.js new file mode 100644 index 0000000..426484d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isTypedArr.js @@ -0,0 +1,24 @@ +var objToStr = require('./objToStr'); +var each = require('./each'); +exports = function(val) { + return !!map[objToStr(val)]; +}; +var map = {}; +each( + [ + 'Int8Array', + 'Int16Array', + 'Int32Array', + 'Uint8Array', + 'Uint8ClampedArray', + 'Uint16Array', + 'Uint32Array', + 'Float32Array', + 'Float64Array' + ], + function(val) { + map['[object ' + val + ']'] = true; + } +); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isUndef.js b/src/miniprogram_npm/miniprogram-licia/isUndef.js new file mode 100644 index 0000000..a9ca7e9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isUndef.js @@ -0,0 +1,5 @@ +exports = function(val) { + return val === void 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isUrl.js b/src/miniprogram_npm/miniprogram-licia/isUrl.js new file mode 100644 index 0000000..6ef8394 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isUrl.js @@ -0,0 +1,6 @@ +exports = function(val) { + return regUrl.test(val); +}; +var regUrl = /^(?:\w+:)?\/\/([^\s.]+\.\S{2}|localhost[:?\d]*)\S*$/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isWeakMap.js b/src/miniprogram_npm/miniprogram-licia/isWeakMap.js new file mode 100644 index 0000000..18ec435 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isWeakMap.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object WeakMap]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isWeakSet.js b/src/miniprogram_npm/miniprogram-licia/isWeakSet.js new file mode 100644 index 0000000..40b03e3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isWeakSet.js @@ -0,0 +1,6 @@ +var objToStr = require('./objToStr'); +exports = function(val) { + return objToStr(val) === '[object WeakSet]'; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/isWindows.js b/src/miniprogram_npm/miniprogram-licia/isWindows.js new file mode 100644 index 0000000..7900475 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/isWindows.js @@ -0,0 +1,4 @@ +var detectOs = require('./detectOs'); +exports = detectOs() === 'windows'; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/jsonClone.js b/src/miniprogram_npm/miniprogram-licia/jsonClone.js new file mode 100644 index 0000000..0e45dc2 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/jsonClone.js @@ -0,0 +1,5 @@ +exports = function(val) { + return JSON.parse(JSON.stringify(val)); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/kebabCase.js b/src/miniprogram_npm/miniprogram-licia/kebabCase.js new file mode 100644 index 0000000..9487732 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/kebabCase.js @@ -0,0 +1,6 @@ +var splitCase = require('./splitCase'); +exports = function(str) { + return splitCase(str).join('-'); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/keyCode.js b/src/miniprogram_npm/miniprogram-licia/keyCode.js new file mode 100644 index 0000000..3d5f234 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/keyCode.js @@ -0,0 +1,61 @@ +var isStr = require('./isStr'); +var invert = require('./invert'); +exports = function(val) { + if (isStr(val)) return codeMap[val]; + return nameMap[val]; +}; +var codeMap = { + backspace: 8, + tab: 9, + enter: 13, + shift: 16, + ctrl: 17, + alt: 18, + 'pause/break': 19, + 'caps lock': 20, + esc: 27, + space: 32, + 'page up': 33, + 'page down': 34, + end: 35, + home: 36, + left: 37, + up: 38, + right: 39, + down: 40, + insert: 45, + delete: 46, + windows: 91, + 'right windows': 92, + 'windows menu': 93, + 'numpad *': 106, + 'numpad +': 107, + 'numpad -': 109, + 'numpad .': 110, + 'numpad /': 111, + 'num lock': 144, + 'scroll lock': 145, + ';': 186, + '=': 187, + ',': 188, + '-': 189, + '.': 190, + '/': 191, + '`': 192, + '[': 219, + '\\': 220, + ']': 221, + "'": 222 +}; + +// Lower case chars +for (var i = 97; i < 123; i++) codeMap[String.fromCharCode(i)] = i - 32; +// Numbers +for (var _i = 48; _i < 58; _i++) codeMap[_i - 48] = _i; +// Function keys +for (var _i2 = 1; _i2 < 13; _i2++) codeMap['f' + _i2] = _i2 + 111; +// Numpad keys +for (var _i3 = 0; _i3 < 10; _i3++) codeMap['numpad ' + _i3] = _i3 + 96; +var nameMap = invert(codeMap); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/keys.js b/src/miniprogram_npm/miniprogram-licia/keys.js new file mode 100644 index 0000000..4f2e4d8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/keys.js @@ -0,0 +1,14 @@ +var has = require('./has'); +if (Object.keys && !false) { + exports = Object.keys; +} else { + exports = function(obj) { + var ret = []; + for (var key in obj) { + if (has(obj, key)) ret.push(key); + } + return ret; + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/last.js b/src/miniprogram_npm/miniprogram-licia/last.js new file mode 100644 index 0000000..057b6c8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/last.js @@ -0,0 +1,6 @@ +exports = function(arr) { + var len = arr ? arr.length : 0; + if (len) return arr[len - 1]; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/levenshtein.js b/src/miniprogram_npm/miniprogram-licia/levenshtein.js new file mode 100644 index 0000000..1232eb8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/levenshtein.js @@ -0,0 +1,59 @@ +var vector = []; +var bChars = []; + +exports = function(a, b) { + if (a === b) return 0; + + if (a.length > b.length) { + var tmp = a; + a = b; + b = tmp; + } + var aLen = a.length; + var bLen = b.length; + if (!aLen) return bLen; + if (!bLen) return aLen; + + while (aLen > 0 && a.charCodeAt(aLen - 1) === b.charCodeAt(bLen - 1)) { + aLen--; + bLen--; + } + if (!aLen) return bLen; + + var start = 0; + while (start < aLen && a.charCodeAt(start) === b.charCodeAt(start)) { + start++; + } + aLen -= start; + bLen -= start; + if (!aLen) return bLen; + var current = 0; + var left; + var above; + var charA; + var i = 0; + while (i < bLen) { + bChars[i] = b.charCodeAt(start + i); + vector[i] = ++i; + } + + for (var _i = 0; _i < aLen; _i++) { + left = _i; + current = _i + 1; + charA = a.charCodeAt(start + _i); + for (var j = 0; j < bLen; j++) { + above = current; + current = left; + left = vector[j]; + if (charA !== bChars[j]) { + if (left < current) current = left; + if (above < current) current = above; + current++; + } + vector[j] = current; + } + } + return current; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/linkify.js b/src/miniprogram_npm/miniprogram-licia/linkify.js new file mode 100644 index 0000000..d346af3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/linkify.js @@ -0,0 +1,16 @@ +var extractUrls = require('./extractUrls'); +var each = require('./each'); +var escapeRegExp = require('./escapeRegExp'); +exports = function(str, hyperlink) { + hyperlink = hyperlink || defHyperlink; + var urlList = extractUrls(str); + each(urlList, function(url) { + str = str.replace(new RegExp(escapeRegExp(url), 'g'), hyperlink); + }); + return str; +}; +function defHyperlink(url) { + return '' + url + ''; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/longest.js b/src/miniprogram_npm/miniprogram-licia/longest.js new file mode 100644 index 0000000..0e98841 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/longest.js @@ -0,0 +1,16 @@ +var size = require('./size'); +exports = function(arr) { + if (arr.length < 1) return; + var ret = arr[0], + retSize = size(arr[0]); + for (var i = 1, len = arr.length; i < len; i++) { + var elSize = size(arr[i]); + if (elSize > retSize) { + ret = arr[i]; + retSize = elSize; + } + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/lowerCase.js b/src/miniprogram_npm/miniprogram-licia/lowerCase.js new file mode 100644 index 0000000..8a34f99 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/lowerCase.js @@ -0,0 +1,6 @@ +var toStr = require('./toStr'); +exports = function(str) { + return toStr(str).toLocaleLowerCase(); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/lpad.js b/src/miniprogram_npm/miniprogram-licia/lpad.js new file mode 100644 index 0000000..0542e91 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/lpad.js @@ -0,0 +1,11 @@ +var repeat = require('./repeat'); +var toStr = require('./toStr'); +exports = function(str, len, chars) { + str = toStr(str); + var strLen = str.length; + chars = chars || ' '; + if (strLen < len) str = (repeat(chars, len - strLen) + str).slice(-len); + return str; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/ltrim.js b/src/miniprogram_npm/miniprogram-licia/ltrim.js new file mode 100644 index 0000000..ba3c858 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/ltrim.js @@ -0,0 +1,30 @@ +var regSpace = /^\s+/; +exports = function(str, chars) { + if (chars == null) { + if (str.trimLeft) { + return str.trimLeft(); + } + return str.replace(regSpace, ''); + } + var start = 0; + var len = str.length; + var charLen = chars.length; + var found = true; + var i; + var c; + while (found && start < len) { + found = false; + i = -1; + c = str.charAt(start); + while (++i < charLen) { + if (c === chars[i]) { + found = true; + start++; + break; + } + } + } + return start >= len ? '' : str.substr(start, len); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/map.js b/src/miniprogram_npm/miniprogram-licia/map.js new file mode 100644 index 0000000..c4d863f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/map.js @@ -0,0 +1,16 @@ +var safeCb = require('./safeCb'); +var keys = require('./keys'); +var isArrLike = require('./isArrLike'); +exports = function(obj, iterator, ctx) { + iterator = safeCb(iterator, ctx); + var _keys = !isArrLike(obj) && keys(obj); + var len = (_keys || obj).length; + var results = Array(len); + for (var i = 0; i < len; i++) { + var curKey = _keys ? _keys[i] : i; + results[i] = iterator(obj[curKey], curKey, obj); + } + return results; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/mapObj.js b/src/miniprogram_npm/miniprogram-licia/mapObj.js new file mode 100644 index 0000000..fa21dc0 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/mapObj.js @@ -0,0 +1,15 @@ +var safeCb = require('./safeCb'); +var keys = require('./keys'); +exports = function(obj, iterator, ctx) { + iterator = safeCb(iterator, ctx); + var _keys = keys(obj); + var len = _keys.length; + var ret = {}; + for (var i = 0; i < len; i++) { + var curKey = _keys[i]; + ret[curKey] = iterator(obj[curKey], curKey, obj); + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/matcher.js b/src/miniprogram_npm/miniprogram-licia/matcher.js new file mode 100644 index 0000000..ed05712 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/matcher.js @@ -0,0 +1,10 @@ +var extendOwn = require('./extendOwn'); +var isMatch = require('./isMatch'); +exports = function(attrs) { + attrs = extendOwn({}, attrs); + return function(obj) { + return isMatch(obj, attrs); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/max.js b/src/miniprogram_npm/miniprogram-licia/max.js new file mode 100644 index 0000000..bde51f1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/max.js @@ -0,0 +1,10 @@ +exports = function() { + var arr = arguments; + var ret = arr[0]; + for (var i = 1, len = arr.length; i < len; i++) { + if (arr[i] > ret) ret = arr[i]; + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/md5.js b/src/miniprogram_npm/miniprogram-licia/md5.js new file mode 100644 index 0000000..fbc45f9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/md5.js @@ -0,0 +1,140 @@ +var isStr = require('./isStr'); +var strToBytes = require('./strToBytes'); +var hex = require('./hex'); +var bytesToWords = require('./bytesToWords'); +var wordsToBytes = require('./wordsToBytes'); +var isNode = require('./isNode'); +var isArr = require('./isArr'); + +exports = function(msg) { + if (isStr(msg)) msg = strToBytes(msg); + var m = bytesToWords(msg); + var l = msg.length * 8; + var a = 1732584193; + var b = -271733879; + var c = -1732584194; + var d = 271733878; + + for (var i = 0; i < m.length; i++) { + m[i] = + (((m[i] << 8) | (m[i] >>> 24)) & 0x00ff00ff) | + (((m[i] << 24) | (m[i] >>> 8)) & 0xff00ff00); + } + + m[l >>> 5] |= 0x80 << l % 32; + m[(((l + 64) >>> 9) << 4) + 14] = l; + for (var _i = 0; _i < m.length; _i += 16) { + var aa = a; + var bb = b; + var cc = c; + var dd = d; + a = FF(a, b, c, d, m[_i + 0], 7, -680876936); + d = FF(d, a, b, c, m[_i + 1], 12, -389564586); + c = FF(c, d, a, b, m[_i + 2], 17, 606105819); + b = FF(b, c, d, a, m[_i + 3], 22, -1044525330); + a = FF(a, b, c, d, m[_i + 4], 7, -176418897); + d = FF(d, a, b, c, m[_i + 5], 12, 1200080426); + c = FF(c, d, a, b, m[_i + 6], 17, -1473231341); + b = FF(b, c, d, a, m[_i + 7], 22, -45705983); + a = FF(a, b, c, d, m[_i + 8], 7, 1770035416); + d = FF(d, a, b, c, m[_i + 9], 12, -1958414417); + c = FF(c, d, a, b, m[_i + 10], 17, -42063); + b = FF(b, c, d, a, m[_i + 11], 22, -1990404162); + a = FF(a, b, c, d, m[_i + 12], 7, 1804603682); + d = FF(d, a, b, c, m[_i + 13], 12, -40341101); + c = FF(c, d, a, b, m[_i + 14], 17, -1502002290); + b = FF(b, c, d, a, m[_i + 15], 22, 1236535329); + a = GG(a, b, c, d, m[_i + 1], 5, -165796510); + d = GG(d, a, b, c, m[_i + 6], 9, -1069501632); + c = GG(c, d, a, b, m[_i + 11], 14, 643717713); + b = GG(b, c, d, a, m[_i + 0], 20, -373897302); + a = GG(a, b, c, d, m[_i + 5], 5, -701558691); + d = GG(d, a, b, c, m[_i + 10], 9, 38016083); + c = GG(c, d, a, b, m[_i + 15], 14, -660478335); + b = GG(b, c, d, a, m[_i + 4], 20, -405537848); + a = GG(a, b, c, d, m[_i + 9], 5, 568446438); + d = GG(d, a, b, c, m[_i + 14], 9, -1019803690); + c = GG(c, d, a, b, m[_i + 3], 14, -187363961); + b = GG(b, c, d, a, m[_i + 8], 20, 1163531501); + a = GG(a, b, c, d, m[_i + 13], 5, -1444681467); + d = GG(d, a, b, c, m[_i + 2], 9, -51403784); + c = GG(c, d, a, b, m[_i + 7], 14, 1735328473); + b = GG(b, c, d, a, m[_i + 12], 20, -1926607734); + a = HH(a, b, c, d, m[_i + 5], 4, -378558); + d = HH(d, a, b, c, m[_i + 8], 11, -2022574463); + c = HH(c, d, a, b, m[_i + 11], 16, 1839030562); + b = HH(b, c, d, a, m[_i + 14], 23, -35309556); + a = HH(a, b, c, d, m[_i + 1], 4, -1530992060); + d = HH(d, a, b, c, m[_i + 4], 11, 1272893353); + c = HH(c, d, a, b, m[_i + 7], 16, -155497632); + b = HH(b, c, d, a, m[_i + 10], 23, -1094730640); + a = HH(a, b, c, d, m[_i + 13], 4, 681279174); + d = HH(d, a, b, c, m[_i + 0], 11, -358537222); + c = HH(c, d, a, b, m[_i + 3], 16, -722521979); + b = HH(b, c, d, a, m[_i + 6], 23, 76029189); + a = HH(a, b, c, d, m[_i + 9], 4, -640364487); + d = HH(d, a, b, c, m[_i + 12], 11, -421815835); + c = HH(c, d, a, b, m[_i + 15], 16, 530742520); + b = HH(b, c, d, a, m[_i + 2], 23, -995338651); + a = II(a, b, c, d, m[_i + 0], 6, -198630844); + d = II(d, a, b, c, m[_i + 7], 10, 1126891415); + c = II(c, d, a, b, m[_i + 14], 15, -1416354905); + b = II(b, c, d, a, m[_i + 5], 21, -57434055); + a = II(a, b, c, d, m[_i + 12], 6, 1700485571); + d = II(d, a, b, c, m[_i + 3], 10, -1894986606); + c = II(c, d, a, b, m[_i + 10], 15, -1051523); + b = II(b, c, d, a, m[_i + 1], 21, -2054922799); + a = II(a, b, c, d, m[_i + 8], 6, 1873313359); + d = II(d, a, b, c, m[_i + 15], 10, -30611744); + c = II(c, d, a, b, m[_i + 6], 15, -1560198380); + b = II(b, c, d, a, m[_i + 13], 21, 1309151649); + a = II(a, b, c, d, m[_i + 4], 6, -145523070); + d = II(d, a, b, c, m[_i + 11], 10, -1120210379); + c = II(c, d, a, b, m[_i + 2], 15, 718787259); + b = II(b, c, d, a, m[_i + 9], 21, -343485551); + a = (a + aa) >>> 0; + b = (b + bb) >>> 0; + c = (c + cc) >>> 0; + d = (d + dd) >>> 0; + } + return hex.encode(wordsToBytes(endian([a, b, c, d]))); +}; +function FF(a, b, c, d, x, s, t) { + var n = a + ((b & c) | (~b & d)) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; +} +function GG(a, b, c, d, x, s, t) { + var n = a + ((b & d) | (c & ~d)) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; +} +function HH(a, b, c, d, x, s, t) { + var n = a + (b ^ c ^ d) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; +} +function II(a, b, c, d, x, s, t) { + var n = a + (c ^ (b | ~d)) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; +} +function endian(n) { + if (n.constructor == Number) { + return (rotl(n, 8) & 0x00ff00ff) | (rotl(n, 24) & 0xff00ff00); + } + for (var i = 0; i < n.length; i++) n[i] = endian(n[i]); + return n; +} +function rotl(n, b) { + return (n << b) | (n >>> (32 - b)); +} +if (isNode) { + var crypto = eval('require')('crypto'); + exports = function(msg) { + if (isArr(msg)) { + msg = Buffer.from(msg); + } + var hash = crypto.createHash('md5'); + hash.update(msg); + return hash.digest('hex'); + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/memStorage.js b/src/miniprogram_npm/miniprogram-licia/memStorage.js new file mode 100644 index 0000000..e53d1e1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/memStorage.js @@ -0,0 +1,53 @@ +var keys = require('./keys'); +exports = { + getItem: function(key) { + return (API_KEYS[key] ? cloak[key] : this[key]) || null; + }, + setItem: function(key, val) { + API_KEYS[key] ? (cloak[key] = val) : (this[key] = val); + }, + removeItem: function(key) { + API_KEYS[key] ? delete cloak[key] : delete this[key]; + }, + key: function(i) { + var keys = enumerableKeys(); + return i >= 0 && i < keys.length ? keys[i] : null; + }, + clear: function() { + var keys = uncloakedKeys(); + + for (var i = 0, key; (key = keys[i]); i++) delete this[key]; + keys = cloakedKeys(); + + for (var _i = 0, _key; (_key = keys[_i]); _i++) delete cloak[_key]; + } +}; +Object.defineProperty(exports, 'length', { + enumerable: false, + configurable: true, + get: function() { + return enumerableKeys().length; + } +}); +var cloak = {}; +var API_KEYS = { + getItem: 1, + setItem: 1, + removeItem: 1, + key: 1, + clear: 1, + length: 1 +}; +function enumerableKeys() { + return uncloakedKeys().concat(cloakedKeys()); +} +function uncloakedKeys() { + return keys(exports).filter(function(key) { + return !API_KEYS[key]; + }); +} +function cloakedKeys() { + return keys(cloak); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/memoize.js b/src/miniprogram_npm/miniprogram-licia/memoize.js new file mode 100644 index 0000000..89c2646 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/memoize.js @@ -0,0 +1,13 @@ +var has = require('./has'); +exports = function(fn, hashFn) { + var memoize = function(key) { + var cache = memoize.cache; + var address = '' + (hashFn ? hashFn.apply(this, arguments) : key); + if (!has(cache, address)) cache[address] = fn.apply(this, arguments); + return cache[address]; + }; + memoize.cache = {}; + return memoize; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/mergeArr.js b/src/miniprogram_npm/miniprogram-licia/mergeArr.js new file mode 100644 index 0000000..7c896f1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/mergeArr.js @@ -0,0 +1,14 @@ +var restArgs = require('./restArgs'); +exports = restArgs(function(first, arrays) { + var end = first.length; + for (var i = 0, len = arrays.length; i < len; i++) { + var arr = arrays[i]; + for (var j = 0, _len = arr.length; j < _len; j++) { + first[end++] = arr[j]; + } + } + first.length = end; + return first; +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/mergeSort.js b/src/miniprogram_npm/miniprogram-licia/mergeSort.js new file mode 100644 index 0000000..3a915e7 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/mergeSort.js @@ -0,0 +1,26 @@ +var isSorted = require('./isSorted'); +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : isSorted.defComparator; + if (arr.length <= 1) return arr; + var middle = floor(arr.length / 2); + var left = arr.slice(0, middle); + var right = arr.slice(middle); + return merge(exports(left, cmp), exports(right, cmp), cmp); +}; +function merge(left, right, cmp) { + var ret = []; + var i = 0; + var j = 0; + while (i < left.length && j < right.length) { + cmp(left[i], right[j]) < 0 ? ret.push(left[i++]) : ret.push(right[j++]); + } + while (i < left.length) ret.push(left[i++]); + while (j < right.length) ret.push(right[j++]); + return ret; +} +var floor = Math.floor; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/methods.js b/src/miniprogram_npm/miniprogram-licia/methods.js new file mode 100644 index 0000000..bc70249 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/methods.js @@ -0,0 +1,10 @@ +var isFn = require('./isFn'); +exports = function(obj) { + var ret = []; + for (var key in obj) { + if (isFn(obj[key])) ret.push(key); + } + return ret.sort(); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/mime.js b/src/miniprogram_npm/miniprogram-licia/mime.js new file mode 100644 index 0000000..d857362 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/mime.js @@ -0,0 +1,83 @@ +var each = require('./each'); +var exts = { + 'image/jpeg': ['jpeg', 'jpg'], + 'image/png': ['png'], + 'image/gif': ['gif'], + 'image/webp': ['webp'], + 'image/tiff': ['tif', 'tiff'], + 'image/bmp': ['bmp'], + 'image/vnd.adobe.photoshop': ['psd'], + 'image/svg+xml': ['svg'], + + 'audio/mp4': ['m4a', 'mp4a'], + 'audio/midi': ['midi'], + 'audio/mpeg': ['mpga', 'mp2', 'mp2a', 'mp3', 'm2a', 'm3a'], + 'audio/ogg': ['ogg'], + 'audio/wav': ['wav'], + + 'video/mp4': ['mp4', 'mp4v', 'mpg4'], + 'video/x-matroska': ['mkv'], + 'video/webm': ['webm'], + 'video/x-msvideo': ['avi'], + 'video/quicktime': ['qt', 'mov'], + 'video/mpeg': ['mpeg', 'mpg', 'mpe', 'm1v', 'm2v'], + 'video/3gpp': ['3gp', '3gpp'], + + 'text/css': ['css'], + 'text/html': ['html', 'htm', 'shtml'], + 'text/yaml': ['yaml', 'yml'], + 'text/csv': ['csv'], + 'text/markdown': ['markdown', 'md'], + 'text/plain': ['txt', 'text', 'conf', 'log', 'ini'], + + 'font/ttf': ['ttf'], + 'font/woff': ['woff'], + 'font/woff2': ['woff2'], + + 'application/zip': ['zip'], + 'application/x-tar': ['tar'], + 'application/x-rar-compressed': ['rar'], + 'application/gzip': ['gz'], + 'application/x-7z-compressed': ['7z'], + 'application/octet-stream': [ + 'bin', + 'so', + 'exe', + 'dll', + 'dmg', + 'iso', + 'msi' + ], + 'application/epub+zip': ['epub'], + 'application/javascript': ['js'], + 'application/json': ['json'], + 'application/msword': ['doc', 'docx', 'dot', 'dotx'], + 'application/vnd.ms-excel': ['xls', 'xlsx', 'xla', 'xlt'], + 'application/vnd.ms-powerpoint': ['ppt', 'pptx', 'pps', 'pot'], + 'application/pdf': ['pdf'], + 'application/wasm': ['wasm'], + 'application/xml': ['xml'], + 'application/xml-dtd': ['dtd'] +}; +var mimeTypes = {}; +each(exts, function(ext, mimeType) { + each(ext, function(e) { + mimeTypes[e] = mimeType; + }); +}); +exports = function(name) { + return (isMimeType(name) ? getExt(name) : getType(name)) || undefined; +}; +function getType(name) { + return mimeTypes[name]; +} +function getExt(name) { + if (exts[name]) { + return exts[name][0]; + } +} +function isMimeType(name) { + return name.indexOf('/') > -1; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/min.js b/src/miniprogram_npm/miniprogram-licia/min.js new file mode 100644 index 0000000..9c8f551 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/min.js @@ -0,0 +1,10 @@ +exports = function() { + var arr = arguments; + var ret = arr[0]; + for (var i = 1, len = arr.length; i < len; i++) { + if (arr[i] < ret) ret = arr[i]; + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/moment.js b/src/miniprogram_npm/miniprogram-licia/moment.js new file mode 100644 index 0000000..5b2b11a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/moment.js @@ -0,0 +1,256 @@ +var Class = require('./Class'); +var toDate = require('./toDate'); +var dateFormat = require('./dateFormat'); +var isLeapYear = require('./isLeapYear'); +var extend = require('./extend'); +var toStr = require('./toStr'); +var isNil = require('./isNil'); +var ms = require('./ms'); +exports = function(val) { + return new Moment(val); +}; +var Moment = Class({ + initialize: function Moment(val) { + this._d = toDate(val); + this._init(); + }, + _init: function() { + var d = this._d; + extend(this, { + _year: d.getFullYear(), + _month: d.getMonth(), + _date: d.getDate(), + _hour: d.getHours(), + _minute: d.getMinutes(), + _second: d.getSeconds(), + _millisecond: d.getMilliseconds() + }); + return this; + }, + format: function(mask) { + return dateFormat(this._d, mask); + }, + isValid: function() { + return !(this._d.toString() === 'Invalid Date'); + }, + isLeapYear: function() { + return isLeapYear(this._year); + }, + isSame: function(that) { + return this.valueOf() === that.valueOf(); + }, + valueOf: function() { + return this._d.getTime(); + }, + isBefore: function(that) { + return this.valueOf() < that.valueOf(); + }, + isAfter: function(that) { + return this.valueOf() > that.valueOf(); + }, + year: makeGetSet('year'), + month: makeGetSet('month'), + date: makeGetSet('date'), + hour: makeGetSet('hour'), + minute: makeGetSet('minute'), + second: makeGetSet('second'), + millisecond: makeGetSet('millisecond'), + unix: function() { + return floor(this.valueOf() / 1000); + }, + clone: function() { + return new Moment(this); + }, + toDate: function() { + return new Date(this._d); + }, + toArray: function() { + return [ + this._year, + this._month, + this._date, + this._hour, + this._minute, + this._second, + this._millisecond + ]; + }, + toJSON: function() { + return this.toISOString(); + }, + toISOString: function() { + return this.toDate().toISOString(); + }, + toObject: function() { + return { + years: this._year, + months: this._month, + date: this._date, + hours: this._hour, + minutes: this._minute, + seconds: this._second, + milliseconds: this._millisecond + }; + }, + toString: function() { + return this._d.toUTCString(); + }, + set: function(unit, num) { + var d = this._d; + unit = normalizeUnit(unit); + switch (unit) { + case 'year': + d.setFullYear(num); + break; + case 'month': + d.setMonth(num); + break; + case 'date': + d.setDate(num); + break; + case 'hour': + d.setHours(num); + break; + case 'minute': + d.setMinutes(num); + break; + case 'second': + d.setSeconds(num); + break; + case 'millisecond': + d.setMilliseconds(num); + break; + } + return this._init(); + }, + startOf: function(unit) { + unit = normalizeUnit(unit); + + /* eslint-disable no-fallthrough */ + switch (unit) { + case 'year': + this.month(0); + case 'month': + this.date(1); + case 'day': + case 'date': + this.hour(0); + case 'hour': + this.minute(0); + case 'minute': + this.second(0); + case 'second': + this.millisecond(0); + } + return this; + }, + endOf: function(unit) { + return this.startOf(unit) + .add(1, unit) + .subtract(1, 'ms'); + }, + daysInMonth: function() { + return this.clone() + .endOf('month') + .date(); + }, + add: createAdder(1), + subtract: createAdder(-1), + diff: function(input, unit, asFloat) { + var that = input instanceof Moment ? input : new Moment(input); + var ret; + unit = normalizeUnit(unit); + var diff = this - that; + switch (unit) { + case 'year': + ret = monthDiff(this, that) / 12; + break; + case 'month': + ret = monthDiff(this, that); + break; + case 'second': + ret = diff / 1e3; + break; + // 1000 + case 'minute': + ret = diff / 6e4; + break; + + case 'hour': + ret = diff / 36e5; + break; + // 1000 * 60 * 60 + case 'day': + ret = diff / 864e5; + break; + + default: + ret = diff; + } + return asFloat ? ret : absFloor(ret); + } +}); +var floor = Math.floor; +var ceil = Math.ceil; +function absFloor(num) { + return num < 0 ? ceil(num) || 0 : floor(num); +} +var unitShorthandMap = { + y: 'year', + M: 'month', + D: 'date', + d: 'day', + h: 'hour', + m: 'minute', + s: 'second', + ms: 'millisecond' +}; +var regEndS = /s$/; + +function normalizeUnit(unit) { + unit = toStr(unit); + if (unitShorthandMap[unit]) return unitShorthandMap[unit]; + return unit.toLowerCase().replace(regEndS, ''); +} +function makeGetSet(unit) { + return function(num) { + return isNil(num) ? this['_' + unit] : this.set(unit, num); + }; +} +function createAdder(dir) { + return function(num, unit) { + unit = normalizeUnit(unit); + if (unit === 'month') return this.month(this._month + dir * num); + if (unit === 'year') return this.year(this._year + dir * num); + var duration = createDuration(num, unit); + this._d = new Date(this.valueOf() + dir * duration); + return this._init(); + }; +} +var msMap = { + day: 'd', + hour: 'h', + minute: 'm', + second: 's', + millisecond: '' +}; +function createDuration(num, unit) { + return ms(num + msMap[unit]); +} + +function monthDiff(a, b) { + var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()); + var anchor = a.clone().add(wholeMonthDiff, 'months'); + var anchor2; + var adjust; + if (b - anchor < 0) { + anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); + adjust = (b - anchor) / (anchor - anchor2); + } else { + anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); + adjust = (b - anchor) / (anchor2 - anchor); + } + return -(wholeMonthDiff + adjust) || 0; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/morse.js b/src/miniprogram_npm/miniprogram-licia/morse.js new file mode 100644 index 0000000..b3de20f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/morse.js @@ -0,0 +1,80 @@ +var upperCase = require('./upperCase'); +var invert = require('./invert'); +exports = { + encode: function(txt) { + var len = txt.length; + var ret = Array(len); + for (var i = 0; i < len; i++) { + var c = upperCase(txt[i]); + ret[i] = map[c] || '?'; + } + return ret.join(' '); + }, + decode: function(morse) { + var ret = morse.split(' '); + for (var i = 0, len = ret.length; i < len; i++) { + ret[i] = decodeMap[ret[i]] || ' '; + } + return ret.join(''); + } +}; + +var map = { + A: '.-', + B: '-...', + C: '-.-.', + D: '-..', + E: '.', + F: '..-.', + G: '--.', + H: '....', + I: '..', + J: '.---', + K: '-.-', + L: '.-..', + M: '--', + N: '-.', + O: '---', + P: '.--.', + Q: '--.-', + R: '.-.', + S: '...', + T: '-', + U: '..-', + V: '...-', + W: '.--', + X: '-..-', + Y: '-.--', + Z: '--..', + Á: '.--.-', + Ä: '.-.-', + É: '..-..', + Ñ: '--.--', + Ö: '---.', + Ü: '..--', + '1': '.----', + '2': '..---', + '3': '...--', + '4': '....-', + '5': '.....', + '6': '-....', + '7': '--...', + '8': '---..', + '9': '----.', + '0': '-----', + ',': '--..--', + '.': '.-.-.-', + '?': '..--..', + ';': '-.-.-', + ':': '---...', + '/': '-..-.', + '-': '-....-', + "'": '.----.', + '()': '-.--.-', + _: '..--.-', + '@': '.--.-.', + ' ': '.......' +}; +var decodeMap = invert(map); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/ms.js b/src/miniprogram_npm/miniprogram-licia/ms.js new file mode 100644 index 0000000..48adcd3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/ms.js @@ -0,0 +1,31 @@ +var toNum = require('./toNum'); +var isStr = require('./isStr'); +exports = function(str) { + if (isStr(str)) { + var match = str.match(regStrTime); + if (!match) return 0; + return toNum(match[1]) * factor[match[2] || 'ms']; + } else { + var num = str; + var suffix = 'ms'; + for (var i = 0, len = suffixList.length; i < len; i++) { + if (num >= factor[suffixList[i]]) { + suffix = suffixList[i]; + break; + } + } + return +(num / factor[suffix]).toFixed(2) + suffix; + } +}; +var factor = { + ms: 1, + s: 1000 +}; +factor.m = factor.s * 60; +factor.h = factor.m * 60; +factor.d = factor.h * 24; +factor.y = factor.d * 365.25; +var suffixList = ['y', 'd', 'h', 'm', 's']; +var regStrTime = /^((?:\d+)?\.?\d+) *(s|m|h|d|y)?$/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/naturalSort.js b/src/miniprogram_npm/miniprogram-licia/naturalSort.js new file mode 100644 index 0000000..0ac670b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/naturalSort.js @@ -0,0 +1,60 @@ +var startWith = require('./startWith'); +var root = require('./root'); +var toStr = require('./toStr'); +exports = function(arr) { + return arr.sort(naturalOrderComparator); +}; + +function naturalOrderComparator(a, b) { + a = toStr(a); + b = toStr(b); + if (startWith(a, '_') && !startWith(b, '_')) { + return 1; + } + if (startWith(b, '_') && !startWith(a, '_')) { + return -1; + } + var chunk = /^\d+|^\D+/; + var chunka, chunkb, anum, bnum; + + while (true) { + if (a) { + if (!b) { + return 1; + } + } else { + if (b) { + return -1; + } + return 0; + } + chunka = a.match(chunk)[0]; + chunkb = b.match(chunk)[0]; + anum = !root.isNaN(chunka); + bnum = !root.isNaN(chunkb); + if (anum && !bnum) { + return -1; + } + if (bnum && !anum) { + return 1; + } + if (anum && bnum) { + var diff = chunka - chunkb; + if (diff) { + return diff; + } + if (chunka.length !== chunkb.length) { + if (!+chunka && !+chunkb) { + return chunka.length - chunkb.length; + } + return chunkb.length - chunka.length; + } + } else if (chunka !== chunkb) { + return chunka < chunkb ? -1 : 1; + } + a = a.substring(chunka.length); + b = b.substring(chunkb.length); + } +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/negate.js b/src/miniprogram_npm/miniprogram-licia/negate.js new file mode 100644 index 0000000..356ed4e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/negate.js @@ -0,0 +1,7 @@ +exports = function(predicate) { + return function() { + return !predicate.apply(this, arguments); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/nextTick.js b/src/miniprogram_npm/miniprogram-licia/nextTick.js new file mode 100644 index 0000000..e24b6dc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/nextTick.js @@ -0,0 +1,18 @@ +if (typeof process === 'object' && process.nextTick && !false) { + exports = process.nextTick; +} else if (typeof setImmediate === 'function') { + exports = function(cb) { + setImmediate(ensureCallable(cb)); + }; +} else { + exports = function(cb) { + setTimeout(ensureCallable(cb), 0); + }; +} +function ensureCallable(fn) { + if (typeof fn !== 'function') + throw new TypeError(fn + ' is not a function'); + return fn; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/noop.js b/src/miniprogram_npm/miniprogram-licia/noop.js new file mode 100644 index 0000000..8d69526 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/noop.js @@ -0,0 +1,3 @@ +exports = function() {}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/normalizeHeader.js b/src/miniprogram_npm/miniprogram-licia/normalizeHeader.js new file mode 100644 index 0000000..c25e63b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/normalizeHeader.js @@ -0,0 +1,21 @@ +var map = require('./map'); +var capitalize = require('./capitalize'); +exports = function(header) { + var ret = specialHeaders[header.toLowerCase()]; + if (!ret) { + ret = map(header.split('-'), capitalize).join('-'); + } + return ret; +}; +var specialHeaders = { + 'content-md5': 'Content-MD5', + dnt: 'DNT', + etag: 'ETag', + 'last-event-id': 'Last-Event-ID', + tcn: 'TCN', + te: 'TE', + 'www-authenticate': 'WWW-Authenticate', + 'x-dnsprefetch-control': 'X-DNSPrefetch-Control' +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/normalizePath.js b/src/miniprogram_npm/miniprogram-licia/normalizePath.js new file mode 100644 index 0000000..89ed263 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/normalizePath.js @@ -0,0 +1,6 @@ +exports = function(path) { + return path.replace(regSlashes, '/'); +}; +var regSlashes = /[\\/]+/g; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/normalizePhone.js b/src/miniprogram_npm/miniprogram-licia/normalizePhone.js new file mode 100644 index 0000000..09827dc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/normalizePhone.js @@ -0,0 +1,22 @@ +var trim = require('./trim'); +exports = function(phone, options) { + phone = trim(phone); + var countryCode = options.countryCode, + _options$trunkPrefix = options.trunkPrefix, + trunkPrefix = + _options$trunkPrefix === void 0 ? false : _options$trunkPrefix; + var plusSign = regPlusSign.test(phone); + phone = phone.replace(regNotDigit, ''); + if (plusSign) { + phone = phone.replace(new RegExp('^'.concat(countryCode)), ''); + } + if (trunkPrefix) { + phone = phone.replace(regTrunkPrefix, ''); + } + return '+'.concat(countryCode + phone); +}; +var regPlusSign = /^\+/; +var regNotDigit = /\D/g; +var regTrunkPrefix = /^\d/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/now.js b/src/miniprogram_npm/miniprogram-licia/now.js new file mode 100644 index 0000000..7363bde --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/now.js @@ -0,0 +1,9 @@ +if (Date.now && !false) { + exports = Date.now; +} else { + exports = function() { + return new Date().getTime(); + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/objToStr.js b/src/miniprogram_npm/miniprogram-licia/objToStr.js new file mode 100644 index 0000000..b276029 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/objToStr.js @@ -0,0 +1,6 @@ +var ObjToStr = Object.prototype.toString; +exports = function(val) { + return ObjToStr.call(val); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/omit.js b/src/miniprogram_npm/miniprogram-licia/omit.js new file mode 100644 index 0000000..e572852 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/omit.js @@ -0,0 +1,6 @@ +var pick = require('./pick'); +exports = function(obj, filter) { + return pick(obj, filter, true); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/once.js b/src/miniprogram_npm/miniprogram-licia/once.js new file mode 100644 index 0000000..73bed34 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/once.js @@ -0,0 +1,5 @@ +var partial = require('./partial'); +var before = require('./before'); +exports = partial(before, 2); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/optimizeCb.js b/src/miniprogram_npm/miniprogram-licia/optimizeCb.js new file mode 100644 index 0000000..eed3595 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/optimizeCb.js @@ -0,0 +1,23 @@ +var isUndef = require('./isUndef'); +exports = function(fn, ctx, argCount) { + if (isUndef(ctx)) return fn; + switch (argCount == null ? 3 : argCount) { + case 1: + return function(val) { + return fn.call(ctx, val); + }; + case 3: + return function(val, idx, collection) { + return fn.call(ctx, val, idx, collection); + }; + case 4: + return function(accumulator, val, idx, collection) { + return fn.call(ctx, accumulator, val, idx, collection); + }; + } + return function() { + return fn.apply(ctx, arguments); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/ordinal.js b/src/miniprogram_npm/miniprogram-licia/ordinal.js new file mode 100644 index 0000000..7d1a778 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/ordinal.js @@ -0,0 +1,17 @@ +exports = function(num) { + var j = num % 10; + var k = num % 100; + var indicator = 'th'; + if (j == 1 && k != 11) { + indicator = 'st'; + } + if (j == 2 && k != 12) { + indicator = 'nd'; + } + if (j == 3 && k != 13) { + indicator = 'rd'; + } + return num + indicator; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/pad.js b/src/miniprogram_npm/miniprogram-licia/pad.js new file mode 100644 index 0000000..af76f5d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/pad.js @@ -0,0 +1,15 @@ +var repeat = require('./repeat'); +var toStr = require('./toStr'); +exports = function(str, len, chars) { + str = toStr(str); + var strLen = str.length; + chars = chars || ' '; + if (strLen < len) { + var padStr = repeat(chars, Math.ceil((len - strLen) / 2)); + str = padStr + str + padStr; + str = str.substr(Math.ceil((str.length - len) / 2), len); + } + return str; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/pairs.js b/src/miniprogram_npm/miniprogram-licia/pairs.js new file mode 100644 index 0000000..c7da88a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/pairs.js @@ -0,0 +1,12 @@ +var keys = require('./keys'); +exports = function(obj) { + var _keys = keys(obj); + var len = _keys.length; + var ret = Array(len); + for (var i = 0; i < len; i++) { + ret[i] = [_keys[i], obj[_keys[i]]]; + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/parallel.js b/src/miniprogram_npm/miniprogram-licia/parallel.js new file mode 100644 index 0000000..f71a428 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/parallel.js @@ -0,0 +1,26 @@ +var noop = require('./noop'); +var each = require('./each'); +var nextTick = require('./nextTick'); +exports = function(tasks, cb) { + cb = cb || noop; + var results = []; + var pending = tasks.length; + if (!pending) return done(null); + each(tasks, function(task, i) { + task(function(err, result) { + taskCb(i, err, result); + }); + }); + function taskCb(i, err, result) { + results[i] = result; + if (--pending === 0 || err) done(err); + } + function done(err) { + nextTick(function() { + cb(err, results); + cb = noop; + }); + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/parseArgs.js b/src/miniprogram_npm/miniprogram-licia/parseArgs.js new file mode 100644 index 0000000..37ec8d1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/parseArgs.js @@ -0,0 +1,72 @@ +var defaults = require('./defaults'); +var toNum = require('./toNum'); +var invert = require('./invert'); +var toBool = require('./toBool'); +exports = function(args, opts) { + opts = opts || {}; + defaults(opts, defOpts); + var names = opts.names; + var shorthands = invert(opts.shorthands); + var remain = []; + var ret = { + remain: remain + }; + var name; + var type; + for (var i = 0, len = args.length; i < len; i++) { + var arg = args[i]; + var nextArg = args[i + 1]; + var match = arg.match(regDoubleDash); + if (match) { + name = match[1]; + type = names[name]; + if (!type) { + remain.push(arg); + } else if (nextArg && !regDashStart.test(nextArg)) { + setArg(name, nextArg); + i++; + } else if (type === 'boolean') { + setArg(name, true); + i++; + } + continue; + } + match = arg.match(regSingleDash); + if (match) { + var letters = match[1]; + for (var j = 0; j < letters.length; j++) { + var letter = letters[j]; + name = shorthands[letter]; + if (!name) continue; + type = names[name]; + if (type === 'boolean') setArg(shorthands[letter], true); + } + continue; + } + remain.push(arg); + } + function setArg(name, val) { + var type = names[name]; + switch (type) { + case 'number': + val = toNum(val); + break; + case 'boolean': + val = toBool(val); + break; + default: + break; + } + ret[name] = val; + } + return ret; +}; +var defOpts = { + names: {}, + shorthands: {} +}; +var regDoubleDash = /^--(.+)/; +var regSingleDash = /^-([^-]+)/; +var regDashStart = /^-/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/parseHtml.js b/src/miniprogram_npm/miniprogram-licia/parseHtml.js new file mode 100644 index 0000000..98840b1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/parseHtml.js @@ -0,0 +1,105 @@ +var last = require('./last'); +var arrToMap = require('./arrToMap'); +var startWith = require('./startWith'); +var lowerCase = require('./lowerCase'); + +exports = function(html, handler) { + var stack = []; + var text; + var lastHtml = html; + while (html) { + text = true; + if (!last(stack) || !SPECIAL[last(stack)]) { + if (startWith(html, ''); + if (endIdx >= 0) { + if (handler.comment) { + handler.comment(html.substring(4, endIdx)); + } + html = html.substring(endIdx + 3); + text = false; + } + } else if (startWith(html, ']*>')).exec( + html + ); + if (execRes) { + var _text2 = html.substring(0, execRes.index); + html = html.substring(execRes.index + execRes[0].length); + if (_text2 && handler.text) handler.text(_text2); + } + parseEndTag('', last(stack)); + } + if (lastHtml === html) { + throw Error('Parse Error: ' + html); + } + lastHtml = html; + } + parseEndTag(); + function parseStartTag(tag, tagName, rest, unary) { + tagName = lowerCase(tagName); + unary = !!unary; + if (!unary) stack.push(tagName); + if (handler.start) { + var attrs = {}; + rest.replace(regAttr, function(all, $1, $2, $3, $4) { + attrs[$1] = $2 || $3 || $4 || ''; + }); + handler.start(tagName, attrs, unary); + } + } + function parseEndTag(tag, tagName) { + tagName = lowerCase(tagName); + var pos; + if (!tagName) { + pos = 0; + } else { + for (pos = stack.length - 1; pos >= 0; pos--) { + if (stack[pos] === tagName) break; + } + } + if (pos >= 0) { + for (var i = stack.length - 1; i >= pos; i--) { + if (handler.end) handler.end(stack[i]); + } + stack.length = pos; + } + } +}; +var regDoctype = /^\s]+))?)*)\s*(\/?)>/i; +var regEndTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/; +var regStartTag = /^<([-A-Za-z0-9_]+)((?:\s+[-A-Za-z0-9_:@.]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/i; +var regAttr = /([-A-Za-z0-9_:@.]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g; + +var SPECIAL = arrToMap('script,style'.split(',')); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/partial.js b/src/miniprogram_npm/miniprogram-licia/partial.js new file mode 100644 index 0000000..637ca0e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/partial.js @@ -0,0 +1,12 @@ +var restArgs = require('./restArgs'); +var toArr = require('./toArr'); +exports = restArgs(function(fn, partials) { + return function() { + var args = []; + args = args.concat(partials); + args = args.concat(toArr(arguments)); + return fn.apply(this, args); + }; +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/pascalCase.js b/src/miniprogram_npm/miniprogram-licia/pascalCase.js new file mode 100644 index 0000000..3d7bbf8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/pascalCase.js @@ -0,0 +1,7 @@ +var camelCase = require('./camelCase'); +var upperFirst = require('./upperFirst'); +exports = function(str) { + return upperFirst(camelCase(str)); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/perfNow.js b/src/miniprogram_npm/miniprogram-licia/perfNow.js new file mode 100644 index 0000000..f7a55bf --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/perfNow.js @@ -0,0 +1,26 @@ +var now = require('./now'); +var root = require('./root'); +var performance = root.performance; +var process = root.process; +var loadTime; +if (performance && performance.now) { + exports = function() { + return performance.now(); + }; +} else if (process && process.hrtime) { + var getNanoSeconds = function() { + var hr = process.hrtime(); + return hr[0] * 1e9 + hr[1]; + }; + loadTime = getNanoSeconds() - process.uptime() * 1e9; + exports = function() { + return (getNanoSeconds() - loadTime) / 1e6; + }; +} else { + loadTime = now(); + exports = function() { + return now() - loadTime; + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/pick.js b/src/miniprogram_npm/miniprogram-licia/pick.js new file mode 100644 index 0000000..1c0451b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/pick.js @@ -0,0 +1,26 @@ +var isStr = require('./isStr'); +var isArr = require('./isArr'); +var contain = require('./contain'); +var each = require('./each'); +exports = function(obj, filter, omit) { + if (isStr(filter)) filter = [filter]; + if (isArr(filter)) { + var keys = filter; + filter = function(val, key) { + return contain(keys, key); + }; + } + var ret = {}; + var iteratee = function(val, key) { + if (filter(val, key)) ret[key] = val; + }; + if (omit) { + iteratee = function(val, key) { + if (!filter(val, key)) ret[key] = val; + }; + } + each(obj, iteratee); + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/pluck.js b/src/miniprogram_npm/miniprogram-licia/pluck.js new file mode 100644 index 0000000..6f3458b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/pluck.js @@ -0,0 +1,7 @@ +var map = require('./map'); +var property = require('./property'); +exports = function(obj, key) { + return map(obj, property(key)); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/precision.js b/src/miniprogram_npm/miniprogram-licia/precision.js new file mode 100644 index 0000000..27ac751 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/precision.js @@ -0,0 +1,11 @@ +exports = function(num) { + num = num.toExponential().match(regExponential); + var coefficient = num[1]; + var exponent = parseInt(num[2], 10); + var places = (coefficient.split('.')[1] || '').length; + var ret = places - exponent; + return ret < 0 ? 0 : ret; +}; +var regExponential = /^(-?\d?\.?\d+)e([+-]\d)+/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/promisify.js b/src/miniprogram_npm/miniprogram-licia/promisify.js new file mode 100644 index 0000000..e94d946 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/promisify.js @@ -0,0 +1,18 @@ +var restArgs = require('./restArgs'); +var root = require('./root'); +exports = function(fn, multiArgs) { + return restArgs(function(args) { + return new root.Promise(function(resolve, reject) { + args.push( + restArgs(function callback(err, values) { + if (err) return reject(err); + if (!multiArgs) return resolve(values[0]); + resolve(values); + }) + ); + fn.apply(this, args); + }); + }); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/property.js b/src/miniprogram_npm/miniprogram-licia/property.js new file mode 100644 index 0000000..f38d7dc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/property.js @@ -0,0 +1,15 @@ +var isArr = require('./isArr'); +var safeGet = require('./safeGet'); +exports = function(path) { + if (!isArr(path)) return shallowProperty(path); + return function(obj) { + return safeGet(obj, path); + }; +}; +function shallowProperty(key) { + return function(obj) { + return obj == null ? void 0 : obj[key]; + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/query.js b/src/miniprogram_npm/miniprogram-licia/query.js new file mode 100644 index 0000000..eb56e0f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/query.js @@ -0,0 +1,50 @@ +var trim = require('./trim'); +var each = require('./each'); +var isUndef = require('./isUndef'); +var isArr = require('./isArr'); +var map = require('./map'); +var isEmpty = require('./isEmpty'); +var filter = require('./filter'); +var isObj = require('./isObj'); +exports = { + parse: function(str) { + var ret = {}; + str = trim(str).replace(regIllegalChars, ''); + each(str.split('&'), function(param) { + var parts = param.split('='); + var key = parts.shift(), + val = parts.length > 0 ? parts.join('=') : null; + key = decodeURIComponent(key); + val = decodeURIComponent(val); + if (isUndef(ret[key])) { + ret[key] = val; + } else if (isArr(ret[key])) { + ret[key].push(val); + } else { + ret[key] = [ret[key], val]; + } + }); + return ret; + }, + stringify: function(obj, arrKey) { + return filter( + map(obj, function(val, key) { + if (isObj(val) && isEmpty(val)) return ''; + if (isArr(val)) return exports.stringify(val, key); + return ( + (arrKey + ? encodeURIComponent(arrKey) + : encodeURIComponent(key)) + + '=' + + encodeURIComponent(val) + ); + }), + function(str) { + return str.length > 0; + } + ).join('&'); + } +}; +var regIllegalChars = /^(\?|#|&)/g; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/quickSort.js b/src/miniprogram_npm/miniprogram-licia/quickSort.js new file mode 100644 index 0000000..c26d469 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/quickSort.js @@ -0,0 +1,32 @@ +var swap = require('./swap'); +var isSorted = require('./isSorted'); +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : isSorted.defComparator; + return quickSort(arr, 0, arr.length - 1, cmp); +}; +function quickSort(arr, left, right, cmp) { + if (arr.length <= 1) return arr; + var idx = partition(arr, left, right, cmp); + if (left < idx - 1) quickSort(arr, left, idx - 1, cmp); + if (idx < right) quickSort(arr, idx, right, cmp); + return arr; +} +function partition(arr, left, right, cmp) { + var pivot = arr[floor((right + left) / 2)]; + while (left <= right) { + while (cmp(arr[left], pivot) < 0) left++; + while (cmp(arr[right], pivot) > 0) right--; + if (left <= right) { + swap(arr, left, right); + left++; + right--; + } + } + return left; +} +var floor = Math.floor; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/raf.js b/src/miniprogram_npm/miniprogram-licia/raf.js new file mode 100644 index 0000000..68e1fee --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/raf.js @@ -0,0 +1,39 @@ +var now = require('./now'); +var isBrowser = require('./isBrowser'); +var raf, cancel; +var lastTime = 0; +if (isBrowser) { + raf = window.requestAnimationFrame; + cancel = window.cancelAnimationFrame; + var vendors = ['ms', 'moz', 'webkit', 'o']; + for (var i = 0, len = vendors.length; i < len && !raf; i++) { + raf = window[vendors[i] + 'RequestAnimationFrame']; + cancel = + window[vendors[i] + 'CancelAnimationFrame'] || + window[vendors[i] + 'CancelRequestAnimationFrame']; + } + if (raf) { + raf = raf.bind(window); + cancel = cancel.bind(window); + } +} +raf = + raf || + function(cb) { + var curTime = now(); + var timeToCall = Math.max(0, 16 - (curTime - lastTime)); + var id = setTimeout(function() { + cb(curTime + timeToCall); + }, timeToCall); + lastTime = curTime + timeToCall; + return id; + }; +cancel = + cancel || + function(id) { + clearTimeout(id); + }; +raf.cancel = cancel; +exports = raf; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/random.js b/src/miniprogram_npm/miniprogram-licia/random.js new file mode 100644 index 0000000..a3b2913 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/random.js @@ -0,0 +1,18 @@ +exports = function(min, max, floating) { + if (max == null) { + max = min; + min = 0; + } + var rand = Math.random(); + if (floating || min % 1 || max % 1) { + return Math.min( + min + + rand * + (max - min + parseFloat('1e-' + ((rand + '').length - 1))), + max + ); + } + return min + Math.floor(rand * (max - min + 1)); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/randomBytes.js b/src/miniprogram_npm/miniprogram-licia/randomBytes.js new file mode 100644 index 0000000..7675fef --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/randomBytes.js @@ -0,0 +1,26 @@ +var random = require('./random'); +var isBrowser = require('./isBrowser'); +var isNode = require('./isNode'); +exports = function(size) { + var ret = new Uint8Array(size); + for (var i = 0; i < size; i++) ret[i] = random(0, 255); + return ret; +}; +var crypto; +if (isBrowser) { + crypto = window.crypto || window.msCrypto; + if (crypto) { + exports = function(size) { + var ret = new Uint8Array(size); + crypto.getRandomValues(ret); + return ret; + }; + } +} else if (isNode) { + crypto = eval('require')('crypto'); + exports = function(size) { + return crypto.randomBytes(size); + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/randomColor.js b/src/miniprogram_npm/miniprogram-licia/randomColor.js new file mode 100644 index 0000000..18cb7a0 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/randomColor.js @@ -0,0 +1,60 @@ +var defaults = require('./defaults'); +var random = require('./random'); +var Color = require('./Color'); +var seedRandom = require('./seedRandom'); +var isFn = require('./isFn'); +exports = function() { + var options = + arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + defaults(options, defOpts); + var count = options.count; + var randomH = options.randomH, + randomL = options.randomL, + randomS = options.randomS; + if (!isFn(randomH)) { + var seed = options.seed || random(0, 100000); + randomH = seedRandom(seed, 0, 360, false); + randomL = seedRandom(seed + 1, 0, 1); + randomS = seedRandom(seed + 2, 0, 1); + } + if (count > 1) { + var colors = []; + for (var i = 0; i < count; i++) { + colors.push( + exports( + defaults( + { + count: 1, + randomH: randomH, + randomL: randomL, + randomS: randomS + }, + options + ) + ) + ); + } + return colors; + } + var hue = options.hue || randomH(); + var lightness = options.lightness || randomL().toFixed(2); + var saturation = options.saturation || randomS().toFixed(2); + var color = new Color({ + val: [hue, Math.round(saturation * 100), Math.round(lightness * 100)], + model: 'hsl' + }); + switch (options.format) { + case 'hsl': + return color.toHsl(); + case 'rgb': + return color.toRgb(); + default: + return color.toHex(); + } +}; +var defOpts = { + count: 1, + format: 'hex' +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/randomId.js b/src/miniprogram_npm/miniprogram-licia/randomId.js new file mode 100644 index 0000000..1661bce --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/randomId.js @@ -0,0 +1,20 @@ +var randomBytes = require('./randomBytes'); +var defSymbols = + 'ModuleSymbhasOwnPr-0123456789ABCDEFGHIJKLNQRTUVWXYZ_cfgijkpqtvxz'; +exports = function() { + var size = + arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 21; + var symbols = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : defSymbols; + var id = ''; + var len = symbols.length; + var bytes = randomBytes(size); + while (0 < size--) { + id += symbols[bytes[size] % len]; + } + return id; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/randomItem.js b/src/miniprogram_npm/miniprogram-licia/randomItem.js new file mode 100644 index 0000000..26886b7 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/randomItem.js @@ -0,0 +1,6 @@ +var random = require('./random'); +exports = function(arr) { + return arr[random(0, arr.length - 1)]; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/range.js b/src/miniprogram_npm/miniprogram-licia/range.js new file mode 100644 index 0000000..548f6f8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/range.js @@ -0,0 +1,13 @@ +exports = function(start, end, step) { + if (end == null) { + end = start || 0; + start = 0; + } + if (!step) step = end < start ? -1 : 1; + var len = Math.max(Math.ceil((end - start) / step), 0); + var ret = Array(len); + for (var i = 0; i < len; i++, start += step) ret[i] = start; + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/rc4.js b/src/miniprogram_npm/miniprogram-licia/rc4.js new file mode 100644 index 0000000..538ab1e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/rc4.js @@ -0,0 +1,46 @@ +var base64 = require('./base64'); +var bytesToStr = require('./bytesToStr'); +var strToBytes = require('./strToBytes'); +exports = { + encrypt: function(key, str) { + return rc4(key, str, false); + }, + decrypt: function(key, str) { + return rc4(key, str, true); + } +}; +function rc4(key, str, decrypt) { + key = strToBytes(key); + if (!decrypt) { + str = strToBytes(str); + } else { + str = base64.decode(str); + } + var result = []; + var s = []; + var j = 0; + var i = 0; + var x; + for (i = 0; i < 256; i++) { + s[i] = i; + } + for (i = 0; i < 256; i++) { + j = (j + s[i] + key[i % key.length]) % 256; + x = s[i]; + s[i] = s[j]; + s[j] = x; + } + i = 0; + j = 0; + for (var y = 0, len = str.length; y < len; y++) { + i = (i + 1) % 256; + j = (j + s[i]) % 256; + x = s[i]; + s[i] = s[j]; + s[j] = x; + result.push(str[y] ^ s[(s[i] + s[j]) % 256]); + } + return !decrypt ? base64.encode(result) : bytesToStr(result); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/reduce.js b/src/miniprogram_npm/miniprogram-licia/reduce.js new file mode 100644 index 0000000..3c0b99f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/reduce.js @@ -0,0 +1,38 @@ +var optimizeCb = require('./optimizeCb'); +var isArrLike = require('./isArrLike'); +var isUndef = require('./isUndef'); +var keys = require('./keys'); +exports = createReduce(1); +exports.create = createReduce; +function createReduce(dir) { + return function(obj, iterator, initial, ctx) { + iterator = optimizeCb(iterator, ctx); + var i, len, key; + if (isArrLike(obj)) { + len = obj.length; + i = dir > 0 ? 0 : len - 1; + if (isUndef(initial)) { + initial = obj[i]; + i += dir; + } + for (; i < len && i >= 0; i += dir) { + initial = iterator(initial, obj[i], i, obj); + } + } else { + var _keys = keys(obj); + len = _keys.length; + i = dir > 0 ? 0 : len - 1; + if (isUndef(initial)) { + initial = obj[_keys[i]]; + i += dir; + } + for (; i < len && i >= 0; i += dir) { + key = _keys[i]; + initial = iterator(initial, obj[key], key, obj); + } + } + return initial; + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/reduceRight.js b/src/miniprogram_npm/miniprogram-licia/reduceRight.js new file mode 100644 index 0000000..d602f3a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/reduceRight.js @@ -0,0 +1,4 @@ +var reduce = require('./reduce'); +exports = reduce.create(-1); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/reject.js b/src/miniprogram_npm/miniprogram-licia/reject.js new file mode 100644 index 0000000..8ba4b5e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/reject.js @@ -0,0 +1,9 @@ +var safeCb = require('./safeCb'); +var negate = require('./negate'); +var filter = require('./filter'); +exports = function(obj, predicate, ctx) { + predicate = safeCb(negate(predicate), ctx); + return filter(obj, predicate); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/remove.js b/src/miniprogram_npm/miniprogram-licia/remove.js new file mode 100644 index 0000000..eba3465 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/remove.js @@ -0,0 +1,18 @@ +var safeCb = require('./safeCb'); +exports = function(arr, iterator, ctx) { + var ret = []; + iterator = safeCb(iterator, ctx); + var i = -1; + var len = arr.length; + while (++i < len) { + var realIdx = i - ret.length; + var val = arr[realIdx]; + if (iterator(val, i, arr)) { + ret.push(val); + arr.splice(realIdx, 1); + } + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/repeat.js b/src/miniprogram_npm/miniprogram-licia/repeat.js new file mode 100644 index 0000000..8fa0132 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/repeat.js @@ -0,0 +1,12 @@ +exports = function(str, n) { + var ret = ''; + if (n < 1) return ''; + while (n > 0) { + if (n & 1) ret += str; + n >>= 1; + str += str; + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/replaceAll.js b/src/miniprogram_npm/miniprogram-licia/replaceAll.js new file mode 100644 index 0000000..119885d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/replaceAll.js @@ -0,0 +1,6 @@ +var escapeRegExp = require('./escapeRegExp'); +exports = function(str, substr, newSubstr) { + return str.replace(new RegExp(escapeRegExp(substr), 'g'), newSubstr); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/restArgs.js b/src/miniprogram_npm/miniprogram-licia/restArgs.js new file mode 100644 index 0000000..5d85ea1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/restArgs.js @@ -0,0 +1,24 @@ +exports = function(fn, startIdx) { + startIdx = startIdx == null ? fn.length - 1 : +startIdx; + return function() { + var len = Math.max(arguments.length - startIdx, 0); + var rest = new Array(len); + var i; + for (i = 0; i < len; i++) rest[i] = arguments[i + startIdx]; + + switch (startIdx) { + case 0: + return fn.call(this, rest); + case 1: + return fn.call(this, arguments[0], rest); + case 2: + return fn.call(this, arguments[0], arguments[1], rest); + } + var args = new Array(startIdx + 1); + for (i = 0; i < startIdx; i++) args[i] = arguments[i]; + args[startIdx] = rest; + return fn.apply(this, args); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/reverse.js b/src/miniprogram_npm/miniprogram-licia/reverse.js new file mode 100644 index 0000000..a7f29cf --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/reverse.js @@ -0,0 +1,11 @@ +exports = function(arr) { + var len = arr.length; + var ret = Array(len); + len--; + for (var i = 0; i <= len; i++) { + ret[len - i] = arr[i]; + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/rgbToHsl.js b/src/miniprogram_npm/miniprogram-licia/rgbToHsl.js new file mode 100644 index 0000000..159016c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/rgbToHsl.js @@ -0,0 +1,37 @@ +exports = function(rgb) { + var r = rgb[0] / 255; + var g = rgb[1] / 255; + var b = rgb[2] / 255; + var min = mMin(r, g, b); + var max = mMax(r, g, b); + var delta = max - min; + var h; + var s; + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else { + h = 4 + (r - g) / delta; + } + h = mMin(h * 60, 360); + if (h < 0) h += 360; + var l = (min + max) / 2; + if (max === min) { + s = 0; + } else if (l <= 0.5) { + s = delta / (max + min); + } else { + s = delta / (2 - max - min); + } + var ret = [round(h), round(s * 100), round(l * 100)]; + if (rgb[3]) ret[3] = rgb[3]; + return ret; +}; +var mMin = Math.min; +var mMax = Math.max; +var round = Math.round; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/root.js b/src/miniprogram_npm/miniprogram-licia/root.js new file mode 100644 index 0000000..6e9d8a4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/root.js @@ -0,0 +1,4 @@ +var isBrowser = require('./isBrowser'); +exports = isBrowser ? window : global; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/rpad.js b/src/miniprogram_npm/miniprogram-licia/rpad.js new file mode 100644 index 0000000..270cb2a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/rpad.js @@ -0,0 +1,11 @@ +var repeat = require('./repeat'); +var toStr = require('./toStr'); +exports = function(str, len, chars) { + str = toStr(str); + var strLen = str.length; + chars = chars || ' '; + if (strLen < len) str = (str + repeat(chars, len - strLen)).slice(0, len); + return str; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/rtrim.js b/src/miniprogram_npm/miniprogram-licia/rtrim.js new file mode 100644 index 0000000..13409ae --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/rtrim.js @@ -0,0 +1,28 @@ +exports = function(str, chars) { + if (chars == null) { + if (str.trimRight) { + return str.trimRight(); + } + chars = ' \r\n\t\f\v'; + } + var end = str.length - 1; + var charLen = chars.length; + var found = true; + var i; + var c; + while (found && end >= 0) { + found = false; + i = -1; + c = str.charAt(end); + while (++i < charLen) { + if (c === chars[i]) { + found = true; + end--; + break; + } + } + } + return end >= 0 ? str.substring(0, end + 1) : ''; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/safeCb.js b/src/miniprogram_npm/miniprogram-licia/safeCb.js new file mode 100644 index 0000000..5d42cca --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/safeCb.js @@ -0,0 +1,15 @@ +var isFn = require('./isFn'); +var isObj = require('./isObj'); +var isArr = require('./isArr'); +var optimizeCb = require('./optimizeCb'); +var matcher = require('./matcher'); +var identity = require('./identity'); +var property = require('./property'); +exports = function(val, ctx, argCount) { + if (val == null) return identity; + if (isFn(val)) return optimizeCb(val, ctx, argCount); + if (isObj(val) && !isArr(val)) return matcher(val); + return property(val); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/safeDel.js b/src/miniprogram_npm/miniprogram-licia/safeDel.js new file mode 100644 index 0000000..fd61980 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/safeDel.js @@ -0,0 +1,16 @@ +var isUndef = require('./isUndef'); +var castPath = require('./castPath'); +exports = function(obj, path) { + path = castPath(path, obj); + var prop, ret; + + while ((prop = path.shift())) { + ret = obj[prop]; + if (path.length === 0) delete obj[prop]; + obj = ret; + if (isUndef(obj)) return; + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/safeGet.js b/src/miniprogram_npm/miniprogram-licia/safeGet.js new file mode 100644 index 0000000..0b882b4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/safeGet.js @@ -0,0 +1,15 @@ +var isUndef = require('./isUndef'); +var castPath = require('./castPath'); +exports = function(obj, path) { + path = castPath(path, obj); + var prop; + prop = path.shift(); + while (!isUndef(prop)) { + obj = obj[prop]; + if (obj == null) return; + prop = path.shift(); + } + return obj; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/safeSet.js b/src/miniprogram_npm/miniprogram-licia/safeSet.js new file mode 100644 index 0000000..4a94b1c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/safeSet.js @@ -0,0 +1,29 @@ +var castPath = require('./castPath'); +var isUndef = require('./isUndef'); +var toStr = require('./toStr'); +var isSymbol = require('./isSymbol'); +var isStr = require('./isStr'); +exports = function(obj, path, val) { + path = castPath(path, obj); + var lastProp = path.pop(); + var prop; + prop = path.shift(); + while (!isUndef(prop)) { + if (!isStr(prop) && !isSymbol(prop)) { + prop = toStr(prop); + } + if ( + prop === '__proto__' || + prop === 'constructor' || + prop === 'prototype' + ) { + return; + } + if (!obj[prop]) obj[prop] = {}; + obj = obj[prop]; + prop = path.shift(); + } + obj[lastProp] = val; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/sameOrigin.js b/src/miniprogram_npm/miniprogram-licia/sameOrigin.js new file mode 100644 index 0000000..4e432e8 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/sameOrigin.js @@ -0,0 +1,14 @@ +var Url = require('./Url'); +exports = function(url1, url2) { + url1 = new Url(url1); + url2 = new Url(url2); + url1.port = url1.port | 0 || (url1.protocol === 'https' ? 443 : 80); + url2.port = url2.port | 0 || (url2.protocol === 'https' ? 443 : 80); + return ( + url1.protocol === url2.protocol && + url1.hostname === url2.hostname && + url1.port === url2.port + ); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/sample.js b/src/miniprogram_npm/miniprogram-licia/sample.js new file mode 100644 index 0000000..1120330 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/sample.js @@ -0,0 +1,18 @@ +var isArrLike = require('./isArrLike'); +var clone = require('./clone'); +var values = require('./values'); +var random = require('./random'); +var swap = require('./swap'); +exports = function(obj, n) { + var sample = isArrLike(obj) ? clone(obj) : values(obj); + var len = sample.length; + n = Math.max(Math.min(n, len), 0); + var last = len - 1; + for (var i = 0; i < n; i++) { + var rand = random(i, last); + swap(sample, i, rand); + } + return sample.slice(0, n); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/seedRandom.js b/src/miniprogram_npm/miniprogram-licia/seedRandom.js new file mode 100644 index 0000000..fe66fa3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/seedRandom.js @@ -0,0 +1,18 @@ +exports = function(seed) { + var min = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var max = + arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1; + var floating = + arguments.length > 3 && arguments[3] !== undefined + ? arguments[3] + : true; + return function() { + seed = (seed * 9301 + 49297) % 233280; + var rnd = seed / 233280.0; + rnd = min + rnd * (max - min); + return floating ? rnd : Math.floor(rnd); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/selectionSort.js b/src/miniprogram_npm/miniprogram-licia/selectionSort.js new file mode 100644 index 0000000..3631337 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/selectionSort.js @@ -0,0 +1,23 @@ +var swap = require('./swap'); +var isSorted = require('./isSorted'); +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : isSorted.defComparator; + var min; + for (var i = 0, len = arr.length; i < len; i++) { + min = i; + for (var j = i + 1; j < len; j++) { + if (cmp(arr[j], arr[min]) < 0) { + min = j; + } + } + if (i != min) { + swap(arr, i, min); + } + } + return arr; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/selector.js b/src/miniprogram_npm/miniprogram-licia/selector.js new file mode 100644 index 0000000..fdb237a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/selector.js @@ -0,0 +1,137 @@ +var trim = require('./trim'); +var each = require('./each'); +var identity = require('./identity'); +var map = require('./map'); + +var whitespace = '[\\x20\\t\\r\\n\\f]'; +var identifier = '(?:\\\\[\\da-fA-F]{1,6}'.concat( + whitespace, + '?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+' +); +var attributes = '\\[' + .concat(whitespace, '*(') + .concat(identifier, ')(?:') + .concat(whitespace, '*([*^$|!~]?=)') + .concat( + whitespace, + '*(?:\'((?:\\\\.|[^\\\\\'])*)\'|"((?:\\\\.|[^\\\\"])*)"|(' + ) + .concat(identifier, '))|)') + .concat(whitespace, '*\\]'); +var pseudos = '::?(' + .concat( + identifier, + ')(?:\\(((\'((?:\\\\.|[^\\\\\'])*)\'|"((?:\\\\.|[^\\\\"])*)")|((?:\\\\.|[^\\\\()[\\]]|' + ) + .concat(attributes, ')*)|.*)\\)|)'); +var regComma = new RegExp('^'.concat(whitespace, '*,').concat(whitespace, '*')); +var regCombinators = new RegExp( + '^' + .concat(whitespace, '*([>+~]|') + .concat(whitespace, ')') + .concat(whitespace, '*') +); +var matchExpr = { + id: { + reg: new RegExp('^#('.concat(identifier, ')')), + value: function(raw) { + return raw.slice(1); + }, + toStr: function(value) { + return '#'.concat(value); + } + }, + class: { + reg: new RegExp('^\\.('.concat(identifier, ')')), + value: function(raw) { + return raw.slice(1); + }, + toStr: function(value) { + return '.'.concat(value); + } + }, + tag: { + reg: new RegExp('^('.concat(identifier, '|[*])')), + value: identity + }, + attribute: { + reg: new RegExp('^'.concat(attributes)), + value: function(raw) { + return raw.slice(1, raw.length - 1); + }, + toStr: function(value) { + return '['.concat(value, ']'); + } + }, + pseudo: { + reg: new RegExp('^'.concat(pseudos)), + value: identity + } +}; +each(matchExpr, function(item) { + if (!item.value) item.value = identity; + if (!item.toStr) item.toStr = identity; +}); +function parse(selector) { + selector = trim(selector); + var groups = []; + var tokens; + var match; + var matched; + while (selector) { + if (!matched || (match = regComma.exec(selector))) { + if (match) { + selector = selector.slice(match[0].length); + } + tokens = []; + groups.push(tokens); + } + matched = false; + if ((match = regCombinators.exec(selector))) { + matched = match.shift(); + selector = selector.slice(matched.length); + matched = trim(matched); + if (!matched) matched = ' '; + tokens.push({ + value: matched, + type: 'combinator' + }); + } + each(matchExpr, function(_ref, type) { + var reg = _ref.reg, + value = _ref.value; + if ((match = reg.exec(selector))) { + matched = match.shift(); + selector = selector.slice(matched.length); + matched = trim(matched); + tokens.push({ + value: value(matched), + type: type + }); + } + }); + if (!matched) { + break; + } + } + return groups; +} +function stringify(groups) { + return map(groups, function(group) { + group = map(group, function(_ref2) { + var type = _ref2.type, + value = _ref2.value; + if (type === 'combinator') { + return value === ' ' ? value : ' '.concat(value, ' '); + } + return matchExpr[type].toStr(value); + }); + return group.join(''); + }).join(', '); +} +exports = { + parse: parse, + stringify: stringify +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/shebang.js b/src/miniprogram_npm/miniprogram-licia/shebang.js new file mode 100644 index 0000000..181ff80 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/shebang.js @@ -0,0 +1,9 @@ +var trim = require('./trim'); +var regShebang = /^#!(.*)/; +exports = function(str) { + var match = str.match(regShebang); + if (!match) return; + return trim(match[1]); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/shellSort.js b/src/miniprogram_npm/miniprogram-licia/shellSort.js new file mode 100644 index 0000000..b05e1ec --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/shellSort.js @@ -0,0 +1,25 @@ +var swap = require('./swap'); +var isSorted = require('./isSorted'); +exports = function(arr) { + var cmp = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : isSorted.defComparator; + var len = arr.length; + var gap = Math.floor(len / 2); + while (gap > 0) { + for (var i = gap; i <= len - gap; i++) { + for (var j = i; j > 0; j -= gap) { + if (cmp(arr[j], arr[j - gap]) < 0) { + swap(arr, j, j - gap); + } else { + break; + } + } + } + gap = Math.floor(gap / 2); + } + return arr; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/shuffle.js b/src/miniprogram_npm/miniprogram-licia/shuffle.js new file mode 100644 index 0000000..672f7b4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/shuffle.js @@ -0,0 +1,6 @@ +var sample = require('./sample'); +exports = function(obj) { + return sample(obj, Infinity); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/size.js b/src/miniprogram_npm/miniprogram-licia/size.js new file mode 100644 index 0000000..fb94ebf --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/size.js @@ -0,0 +1,7 @@ +var isArrLike = require('./isArrLike'); +var keys = require('./keys'); +exports = function(obj) { + return isArrLike(obj) ? obj.length : keys(obj).length; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/sizeof.js b/src/miniprogram_npm/miniprogram-licia/sizeof.js new file mode 100644 index 0000000..81d544b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/sizeof.js @@ -0,0 +1,47 @@ +var isArr = require('./isArr'); +var keys = require('./keys'); +var isBuffer = require('./isBuffer'); +var isNull = require('./isNull'); + +var strSize = 2; +var boolSize = 4; +var numSize = 8; +exports = function(obj) { + return sizeof(obj, { + values: [] + }); +}; +function sizeof(obj, _ref) { + var values = _ref.values; + var t = typeof obj; + if (t === 'string') return obj.length * strSize; + if (t === 'number') return numSize; + if (t === 'boolean') return boolSize; + var size = 0; + if (t === 'object' && !isNull(obj)) { + if (values.indexOf(obj) > -1) { + return 0; + } + values.push(obj); + if (isArr(obj)) { + for (var i = 0, len = obj.length; i < len; i++) { + size += sizeof(obj[i], { + values: values + }); + } + } else { + var _keys = keys(obj); + for (var _i = 0, _len = _keys.length; _i < _len; _i++) { + var key = _keys[_i]; + size += key.length * strSize; + size += sizeof(obj[key], { + values: values + }); + } + } + } + if (isBuffer(obj)) return obj.length; + return size; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/sleep.js b/src/miniprogram_npm/miniprogram-licia/sleep.js new file mode 100644 index 0000000..0196daf --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/sleep.js @@ -0,0 +1,7 @@ +exports = function(timeout) { + return new Promise(function(resolve) { + return setTimeout(resolve, timeout); + }); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/slice.js b/src/miniprogram_npm/miniprogram-licia/slice.js new file mode 100644 index 0000000..73f979a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/slice.js @@ -0,0 +1,22 @@ +exports = function(arr, start, end) { + var len = arr.length; + if (start == null) { + start = 0; + } else if (start < 0) { + start = Math.max(len + start, 0); + } else { + start = Math.min(start, len); + } + if (end == null) { + end = len; + } else if (end < 0) { + end = Math.max(len + end, 0); + } else { + end = Math.min(end, len); + } + var ret = []; + while (start < end) ret.push(arr[start++]); + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/slugify.js b/src/miniprogram_npm/miniprogram-licia/slugify.js new file mode 100644 index 0000000..ed6ebd5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/slugify.js @@ -0,0 +1,27 @@ +var defaults = require('./defaults'); +var each = require('./each'); +var reduce = require('./reduce'); +exports = function(str) { + var replacement = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + defaults(replacement, defReplacement); + return reduce( + str, + function(result, char) { + return result + (replacement[char] || char); + }, + '' + ).replace(regForbidden, ''); +}; +var regForbidden = /[^\w\s$*_+~.()'"!\-:@]/g; + +var REPLACEMENT = + '$ dollar,% percent,& and,< less,> greater,| or,¢ cent,£ pound,¤ currency,¥ yen,© (c),ª a,® (r),º o,À A,Á A, A,à A,Ä A,Å A,Æ AE,Ç C,È E,É E,Ê E,Ë E,Ì I,Í I,Î I,Ï I,Ð D,Ñ N,Ò O,Ó O,Ô O,Õ O,Ö O,Ø O,Ù U,Ú U,Û U,Ü U,Ý Y,Þ TH,ß ss,à a,á a,â a,ã a,ä a,å a,æ ae,ç c,è e,é e,ê e,ë e,ì i,í i,î i,ï i,ð d,ñ n,ò o,ó o,ô o,õ o,ö o,ø o,ù u,ú u,û u,ü u,ý y,þ th,ÿ y,Ā A,ā a,Ă A,ă a,Ą A,ą a,Ć C,ć c,Č C,č c,Ď D,ď d,Đ DJ,đ dj,Ē E,ē e,Ė E,ė e,Ę e,ę e,Ě E,ě e,Ğ G,ğ g,Ģ G,ģ g,Ĩ I,ĩ i,Ī i,ī i,Į I,į i,İ I,ı i,Ķ k,ķ k,Ļ L,ļ l,Ľ L,ľ l,Ł L,ł l,Ń N,ń n,Ņ N,ņ n,Ň N,ň n,Ő O,ő o,Œ OE,œ oe,Ŕ R,ŕ r,Ř R,ř r,Ś S,ś s,Ş S,ş s,Š S,š s,Ţ T,ţ t,Ť T,ť t,Ũ U,ũ u,Ū u,ū u,Ů U,ů u,Ű U,ű u,Ų U,ų u,Ź Z,ź z,Ż Z,ż z,Ž Z,ž z,ƒ f,Ơ O,ơ o,Ư U,ư u,Lj LJ,lj lj,Nj NJ,nj nj,Ș S,ș s,Ț T,ț t,˚ o,Ά A,Έ E,Ή H,Ί I,Ό O,Ύ Y,Ώ W,ΐ i,Α A,Β B,Γ G,Δ D,Ε E,Ζ Z,Η H,Θ 8,Ι I,Κ K,Λ L,Μ M,Ν N,Ξ 3,Ο O,Π P,Ρ R,Σ S,Τ T,Υ Y,Φ F,Χ X,Ψ PS,Ω W,Ϊ I,Ϋ Y,ά a,έ e,ή h,ί i,ΰ y,α a,β b,γ g,δ d,ε e,ζ z,η h,θ 8,ι i,κ k,λ l,μ m,ν n,ξ 3,ο o,π p,ρ r,ς s,σ s,τ t,υ y,φ f,χ x,ψ ps,ω w,ϊ i,ϋ y,ό o,ύ y,ώ w,Ё Yo,Ђ DJ,Є Ye,І I,Ї Yi,Ј J,Љ LJ,Њ NJ,Ћ C,Џ DZ,А A,Б B,В V,Г G,Д D,Е E,Ж Zh,З Z,И I,Й J,К K,Л L,М M,Н N,О O,П P,Р R,С S,Т T,У U,Ф F,Х H,Ц C,Ч Ch,Ш Sh,Щ Sh,Ъ U,Ы Y,Ь ,Э E,Ю Yu,Я Ya,а a,б b,в v,г g,д d,е e,ж zh,з z,и i,й j,к k,л l,м m,н n,о o,п p,р r,с s,т t,у u,ф f,х h,ц c,ч ch,ш sh,щ sh,ъ u,ы y,ь ,э e,ю yu,я ya,ё yo,ђ dj,є ye,і i,ї yi,ј j,љ lj,њ nj,ћ c,џ dz,Ґ G,ґ g,฿ baht,ა a,ბ b,გ g,დ d,ე e,ვ v,ზ z,თ t,ი i,კ k,ლ l,მ m,ნ n,ო o,პ p,ჟ zh,რ r,ს s,ტ t,უ u,ფ f,ქ k,ღ gh,ყ q,შ sh,ჩ ch,ც ts,ძ dz,წ ts,ჭ ch,ხ kh,ჯ j,ჰ h,ẞ SS,Ạ A,ạ a,Ả A,ả a,Ấ A,ấ a,Ầ A,ầ a,Ẩ A,ẩ a,Ẫ A,ẫ a,Ậ A,ậ a,Ắ A,ắ a,Ằ A,ằ a,Ẳ A,ẳ a,Ẵ A,ẵ a,Ặ A,ặ a,Ẹ E,ẹ e,Ẻ E,ẻ e,Ẽ E,ẽ e,Ế E,ế e,Ề E,ề e,Ể E,ể e,Ễ E,ễ e,Ệ E,ệ e,Ỉ I,ỉ i,Ị I,ị i,Ọ O,ọ o,Ỏ O,ỏ o,Ố O,ố o,Ồ O,ồ o,Ổ O,ổ o,Ỗ O,ỗ o,Ộ O,ộ o,Ớ O,ớ o,Ờ O,ờ o,Ở O,ở o,Ỡ O,ỡ o,Ợ O,ợ o,Ụ U,ụ u,Ủ U,ủ u,Ứ U,ứ u,Ừ U,ừ u,Ử U,ử u,Ữ U,ữ u,Ự U,ự u,Ỳ Y,ỳ y,Ỵ Y,ỵ y,Ỷ Y,ỷ y,Ỹ Y,ỹ y,‘ \',’ \',“ ",” ",† +,• *,… ...,₠ ecu,₢ cruzeiro,₣ french franc,₤ lira,₥ mill,₦ naira,₧ peseta,₨ rupee,₩ won,₪ new shequel,₫ dong,€ euro,₭ kip,₮ tugrik,₯ drachma,₰ penny,₱ peso,₲ guarani,₳ austral,₴ hryvnia,₵ cedi,₹ indian rupee,₽ russian ruble,₿ bitcoin,℠ sm,™ tm,∂ d,∆ delta,∑ sum,∞ infinity,♥ love,元 yuan,円 yen,﷼ rial'; +var defReplacement = {}; +each(REPLACEMENT.split(','), function(item) { + item = item.split(' '); + defReplacement[item[0]] = item[1]; +}); +defReplacement[' '] = '-'; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/snakeCase.js b/src/miniprogram_npm/miniprogram-licia/snakeCase.js new file mode 100644 index 0000000..49f106e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/snakeCase.js @@ -0,0 +1,6 @@ +var splitCase = require('./splitCase'); +exports = function(str) { + return splitCase(str).join('_'); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/some.js b/src/miniprogram_npm/miniprogram-licia/some.js new file mode 100644 index 0000000..8868c75 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/some.js @@ -0,0 +1,15 @@ +var safeCb = require('./safeCb'); +var isArrLike = require('./isArrLike'); +var keys = require('./keys'); +exports = function(obj, predicate, ctx) { + predicate = safeCb(predicate, ctx); + var _keys = !isArrLike(obj) && keys(obj); + var len = (_keys || obj).length; + for (var i = 0; i < len; i++) { + var key = _keys ? _keys[i] : i; + if (predicate(obj[key], key, obj)) return true; + } + return false; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/sortBy.js b/src/miniprogram_npm/miniprogram-licia/sortBy.js new file mode 100644 index 0000000..6169e17 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/sortBy.js @@ -0,0 +1,28 @@ +var safeCb = require('./safeCb'); +var pluck = require('./pluck'); +var map = require('./map'); +var isUndef = require('./isUndef'); +exports = function(obj, iteratee, ctx) { + iteratee = safeCb(iteratee, ctx); + var idx = 0; + return pluck( + map(obj, function(val, key) { + return { + val: val, + idx: idx++, + criteria: iteratee(val, key, obj) + }; + }).sort(function(left, right) { + var a = left.criteria; + var b = right.criteria; + if (a !== b) { + if (a > b || isUndef(a)) return 1; + if (a < b || isUndef(b)) return -1; + } + return left.idx - right.idx; + }), + 'val' + ); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/sortKeys.js b/src/miniprogram_npm/miniprogram-licia/sortKeys.js new file mode 100644 index 0000000..2fe3d51 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/sortKeys.js @@ -0,0 +1,56 @@ +var isSorted = require('./isSorted'); +var defaults = require('./defaults'); +var keys = require('./keys'); +var isArr = require('./isArr'); +var isObj = require('./isObj'); +exports = function(obj) { + var options = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + defaults(options, defOpts); + var deep = options.deep, + comparator = options.comparator; + var visited = []; + var visitedResult = []; + function sort(obj) { + var idx = visited.indexOf(obj); + if (idx > -1) { + return visitedResult[idx]; + } + var result; + if (isArr(obj)) { + result = []; + visited.push(obj); + visitedResult.push(result); + for (var i = 0, len = obj.length; i < len; i++) { + var value = obj[i]; + if (deep && isObj(value)) { + result[i] = sort(value); + } else { + result[i] = value; + } + } + } else { + result = {}; + visited.push(obj); + visitedResult.push(result); + var _keys = keys(obj).sort(comparator); + for (var _i = 0, _len = _keys.length; _i < _len; _i++) { + var key = _keys[_i]; + var _value = obj[key]; + if (deep && isObj(_value)) { + result[key] = sort(_value); + } else { + result[key] = _value; + } + } + } + return result; + } + return sort(obj); +}; +var defOpts = { + deep: false, + comparator: isSorted.defComparator +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/spaceCase.js b/src/miniprogram_npm/miniprogram-licia/spaceCase.js new file mode 100644 index 0000000..31704ce --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/spaceCase.js @@ -0,0 +1,6 @@ +var splitCase = require('./splitCase'); +exports = function(str) { + return splitCase(str).join(' '); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/splitCase.js b/src/miniprogram_npm/miniprogram-licia/splitCase.js new file mode 100644 index 0000000..e97d17f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/splitCase.js @@ -0,0 +1,13 @@ +var regUpperCase = /([A-Z])/g; +var regSeparator = /[_.\- ]+/g; +var regTrim = /(^-)|(-$)/g; +exports = function(str) { + str = str + .replace(regUpperCase, '-$1') + .toLowerCase() + .replace(regSeparator, '-') + .replace(regTrim, ''); + return str.split('-'); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/splitPath.js b/src/miniprogram_npm/miniprogram-licia/splitPath.js new file mode 100644 index 0000000..8306d2b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/splitPath.js @@ -0,0 +1,11 @@ +exports = function(path) { + var match = path.match(regSplit); + return { + dir: match[1], + name: match[2], + ext: match[3] + }; +}; +var regSplit = /^([\s\S]*?)((?:\.{1,2}|[^\\/]+?|)(\.[^./\\]*|))(?:[\\/]*)$/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/startWith.js b/src/miniprogram_npm/miniprogram-licia/startWith.js new file mode 100644 index 0000000..8501088 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/startWith.js @@ -0,0 +1,5 @@ +exports = function(str, prefix) { + return str.indexOf(prefix) === 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/strHash.js b/src/miniprogram_npm/miniprogram-licia/strHash.js new file mode 100644 index 0000000..4c7f580 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/strHash.js @@ -0,0 +1,10 @@ +exports = function(str) { + var hash = 5381; + var i = str.length; + while (i) { + hash = (hash << 5) + hash + str.charCodeAt(--i); + } + return hash >>> 0; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/strToBytes.js b/src/miniprogram_npm/miniprogram-licia/strToBytes.js new file mode 100644 index 0000000..734bdbf --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/strToBytes.js @@ -0,0 +1,21 @@ +var utf8 = require('./utf8'); +var hex = require('./hex'); +var base64 = require('./base64'); +exports = function(str) { + var encoding = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : 'utf8'; + if (encoding === 'hex') return hex.decode(str); + if (encoding === 'base64') return base64.decode(str); + var bytes = []; + if (encoding === 'utf8') { + str = utf8.encode(str); + } + for (var i = 0, len = str.length; i < len; i++) { + bytes.push(str.charCodeAt(i) & 0xff); + } + return bytes; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/strTpl.js b/src/miniprogram_npm/miniprogram-licia/strTpl.js new file mode 100644 index 0000000..a5ab0d7 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/strTpl.js @@ -0,0 +1,10 @@ +var safeGet = require('./safeGet'); +var toStr = require('./toStr'); +var regSep = /{{(.*?)}}/g; +exports = function(str, data) { + return str.replace(regSep, function(match, key) { + return toStr(safeGet(data, key)); + }); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/strWidth.js b/src/miniprogram_npm/miniprogram-licia/strWidth.js new file mode 100644 index 0000000..5ef921e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/strWidth.js @@ -0,0 +1,17 @@ +var stripAnsi = require('./stripAnsi'); +var isFullWidth = require('./isFullWidth'); +exports = function(str) { + str = stripAnsi(str); + var width = 0; + for (var i = 0, len = str.length; i < len; i++) { + var c = str.codePointAt(i); + + if (c <= 31 || c === 127) { + continue; + } + width += isFullWidth(c) ? 2 : 1; + } + return width; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stringify.js b/src/miniprogram_npm/miniprogram-licia/stringify.js new file mode 100644 index 0000000..6ed3083 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stringify.js @@ -0,0 +1,44 @@ +var type = require('./type'); +var upperFirst = require('./upperFirst'); +var toStr = require('./toStr'); +var isUndef = require('./isUndef'); +var isFn = require('./isFn'); +var isRegExp = require('./isRegExp'); +exports = function(obj, spaces) { + return JSON.stringify(obj, serializer(), spaces); +}; +function serializer() { + var stack = []; + var keys = []; + return function(key, val) { + if (stack.length > 0) { + var pos = stack.indexOf(this); + if (pos > -1) { + stack.splice(pos + 1); + keys.splice(pos, Infinity, key); + } else { + stack.push(this); + keys.push(key); + } + var valPos = stack.indexOf(val); + if (valPos > -1) { + if (stack[0] === val) { + val = '[Circular ~]'; + } else { + val = + '[Circular ~.' + keys.slice(0, valPos).join('.') + ']'; + } + } + } else { + stack.push(val); + } + if (isRegExp(val) || isFn(val)) { + val = '[' + upperFirst(type(val)) + ' ' + toStr(val) + ']'; + } else if (isUndef(val)) { + val = null; + } + return val; + }; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stringifyAll.js b/src/miniprogram_npm/miniprogram-licia/stringifyAll.js new file mode 100644 index 0000000..b27af01 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stringifyAll.js @@ -0,0 +1,403 @@ +var escapeJsStr = require('./escapeJsStr'); +var type = require('./type'); +var toStr = require('./toStr'); +var endWith = require('./endWith'); +var toSrc = require('./toSrc'); +var keys = require('./keys'); +var each = require('./each'); +var Class = require('./Class'); +var getProto = require('./getProto'); +var difference = require('./difference'); +var extend = require('./extend'); +var isPromise = require('./isPromise'); +var filter = require('./filter'); +var now = require('./now'); +var allKeys = require('./allKeys'); +var contain = require('./contain'); +var isObj = require('./isObj'); +var isMiniProgram = require('./isMiniProgram'); +var create = require('./create'); +var startWith = require('./startWith'); +var safeSet = require('./safeSet'); +var defineProp = require('./defineProp'); +var pick = require('./pick'); +var isArrLike = require('./isArrLike'); +exports = function(obj) { + var _ref = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : {}, + self = _ref.self, + _ref$startTime = _ref.startTime, + startTime = _ref$startTime === void 0 ? now() : _ref$startTime, + _ref$timeout = _ref.timeout, + timeout = _ref$timeout === void 0 ? 0 : _ref$timeout, + _ref$depth = _ref.depth, + depth = _ref$depth === void 0 ? 0 : _ref$depth, + _ref$curDepth = _ref.curDepth, + curDepth = _ref$curDepth === void 0 ? 1 : _ref$curDepth, + _ref$visitor = _ref.visitor, + visitor = _ref$visitor === void 0 ? new Visitor() : _ref$visitor, + _ref$unenumerable = _ref.unenumerable, + unenumerable = _ref$unenumerable === void 0 ? false : _ref$unenumerable, + _ref$symbol = _ref.symbol, + symbol = _ref$symbol === void 0 ? false : _ref$symbol, + _ref$accessGetter = _ref.accessGetter, + accessGetter = _ref$accessGetter === void 0 ? false : _ref$accessGetter, + _ref$ignore = _ref.ignore, + ignore = _ref$ignore === void 0 ? [] : _ref$ignore; + var json = ''; + var options = { + visitor: visitor, + unenumerable: unenumerable, + symbol: symbol, + accessGetter: accessGetter, + depth: depth, + curDepth: curDepth + 1, + timeout: timeout, + startTime: startTime, + ignore: ignore + }; + var t = type(obj, false); + if (t === 'String') { + json = wrapStr(obj); + } else if (t === 'Number') { + json = toStr(obj); + if (endWith(json, 'Infinity')) { + json = '{"value":"'.concat(json, '","type":"Number"}'); + } + } else if (t === 'NaN') { + json = '{"value":"NaN","type":"Number"}'; + } else if (t === 'Boolean') { + json = obj ? 'true' : 'false'; + } else if (t === 'Null') { + json = 'null'; + } else if (t === 'Undefined') { + json = '{"type":"Undefined"}'; + } else if (t === 'Symbol') { + var val = 'Symbol'; + try { + val = toStr(obj); + } catch (e) {} + json = '{"value":'.concat(wrapStr(val), ',"type":"Symbol"}'); + } else { + if (timeout && now() - startTime > timeout) { + return wrapStr('Timeout'); + } + if (depth && curDepth > depth) { + return wrapStr('{...}'); + } + json = '{'; + var parts = []; + var visitedObj = visitor.get(obj); + var id; + if (visitedObj) { + id = visitedObj.id; + parts.push('"reference":'.concat(id)); + } else { + id = visitor.set(obj); + parts.push('"id":'.concat(id)); + } + parts.push('"type":"'.concat(t, '"')); + if (endWith(t, 'Function')) { + parts.push('"value":'.concat(wrapStr(toSrc(obj)))); + } else if (t === 'RegExp') { + parts.push('"value":'.concat(wrapStr(obj))); + } + if (!visitedObj) { + var enumerableKeys = keys(obj); + if (enumerableKeys.length) { + parts.push( + iterateObj( + 'enumerable', + enumerableKeys, + self || obj, + options + ) + ); + } + if (unenumerable) { + var unenumerableKeys = difference( + allKeys(obj, { + prototype: false, + unenumerable: true + }), + enumerableKeys + ); + if (unenumerableKeys.length) { + parts.push( + iterateObj( + 'unenumerable', + unenumerableKeys, + self || obj, + options + ) + ); + } + } + if (symbol) { + var symbolKeys = filter( + allKeys(obj, { + prototype: false, + symbol: true + }), + function(key) { + return typeof key === 'symbol'; + } + ); + if (symbolKeys.length) { + parts.push( + iterateObj('symbol', symbolKeys, self || obj, options) + ); + } + } + var prototype = getProto(obj); + if (prototype && !contain(ignore, prototype)) { + var proto = '"proto":'.concat( + exports( + prototype, + extend(options, { + self: self || obj + }) + ) + ); + parts.push(proto); + } + } + json += parts.join(',') + '}'; + } + return json; +}; +function iterateObj(name, keys, obj, options) { + var parts = []; + each(keys, function(key) { + var val; + var descriptor = Object.getOwnPropertyDescriptor(obj, key); + var hasGetter = descriptor && descriptor.get; + var hasSetter = descriptor && descriptor.set; + if (!options.accessGetter && hasGetter) { + val = '(...)'; + } else { + try { + val = obj[key]; + if (contain(options.ignore, val)) { + return; + } + if (isPromise(val)) { + val.catch(function() {}); + } + } catch (e) { + val = e.message; + } + } + parts.push(''.concat(wrapKey(key), ':').concat(exports(val, options))); + if (hasGetter) { + parts.push( + '' + .concat(wrapKey('get ' + toStr(key)), ':') + .concat(exports(descriptor.get, options)) + ); + } + if (hasSetter) { + parts.push( + '' + .concat(wrapKey('set ' + toStr(key)), ':') + .concat(exports(descriptor.set, options)) + ); + } + }); + return '"'.concat(name, '":{') + parts.join(',') + '}'; +} +function wrapKey(key) { + return '"'.concat(escapeJsonStr(key), '"'); +} +function wrapStr(str) { + return '"'.concat(escapeJsonStr(toStr(str)), '"'); +} +function escapeJsonStr(str) { + return escapeJsStr(str) + .replace(/\\'/g, "'") + .replace(/\t/g, '\\t'); +} +var Visitor = Class({ + initialize: function() { + this.id = 1; + this.visited = []; + }, + set: function(val) { + var visited = this.visited, + id = this.id; + var obj = { + id: id, + val: val + }; + visited.push(obj); + this.id++; + return id; + }, + get: function(val) { + var visited = this.visited; + for (var i = 0, len = visited.length; i < len; i++) { + var obj = visited[i]; + if (val === obj.val) return obj; + } + return false; + } +}); +exports.parse = function(str) { + var map = {}; + var obj = parse(JSON.parse(str), { + map: map + }); + correctReference(map); + return obj; +}; +function correctReference(map) { + each(map, function(obj) { + var enumerableKeys = keys(obj); + for (var i = 0, len = enumerableKeys.length; i < len; i++) { + var key = enumerableKeys[i]; + if (isObj(obj[key])) { + var reference = obj[key].reference; + if (reference && map[reference]) { + obj[key] = map[reference]; + } + } + } + var proto = getProto(obj); + if (proto && proto.reference) { + if (map[proto.reference]) { + Object.setPrototypeOf(obj, map[proto.reference]); + } + } + }); +} +function parse(obj, options) { + var map = options.map; + if (!isObj(obj)) { + return obj; + } + var id = obj.id, + type = obj.type, + value = obj.value, + proto = obj.proto, + reference = obj.reference; + var enumerable = obj.enumerable, + unenumerable = obj.unenumerable; + if (reference) { + return obj; + } + if (type === 'Number') { + if (value === 'Infinity') { + return Number.POSITIVE_INFINITY; + } else if (value === '-Infinity') { + return Number.NEGATIVE_INFINITY; + } + return NaN; + } else if (type === 'Undefined') { + return undefined; + } + var newObj; + if (type === 'Function') { + newObj = function() {}; + newObj.toString = function() { + return value; + }; + if (proto) { + Object.setPrototypeOf(newObj, parse(proto, options)); + } + } else if (type === 'RegExp') { + newObj = strToRegExp(value); + } else { + if (type !== 'Object') { + var Fn; + if (!isMiniProgram) { + Fn = new Function(type, ''); + } else { + Fn = function() {}; + } + if (proto) { + Fn.prototype = parse(proto, options); + } + newObj = new Fn(); + } else { + if (proto) { + newObj = create(parse(proto, options)); + } else { + newObj = create(null); + } + } + } + var defineProps = {}; + if (enumerable) { + var len; + if (isArrLike(enumerable)) { + len = enumerable.length; + delete enumerable.length; + } + enumerable = pick(enumerable, function(value, key) { + return !handleGetterSetter(enumerable, value, key); + }); + each(enumerable, function(value, key) { + var defineProp = defineProps[key] || {}; + if (!defineProp.get) { + newObj[key] = parse(value, options); + } + }); + if (len) { + newObj.length = len; + } + } + if (unenumerable) { + unenumerable = pick(unenumerable, function(value, key) { + return !handleGetterSetter(unenumerable, value, key); + }); + each(unenumerable, function(value, key) { + var defineProp = defineProps[key] || {}; + if (!defineProp.get) { + value = parse(value, options); + if (isObj(value) && value.reference) { + var _reference = value.reference; + value = function() { + return map[_reference]; + }; + defineProp.get = value; + } else { + defineProp.value = value; + } + } + defineProp.enumerable = false; + defineProps[key] = defineProp; + }); + } + defineProp(newObj, defineProps); + function handleGetterSetter(obj, val, key) { + key = toStr(key); + var isGetterAndSetter = false; + each(['get', 'set'], function(type) { + if (startWith(key, type + ' ')) { + var realKey = key.replace(type + ' ', ''); + if (obj[realKey]) { + val = parse(val, options); + if (val === 'Timeout') { + val = retTimeout; + } + safeSet(defineProps, [realKey, type], val); + isGetterAndSetter = true; + } + } + }); + return isGetterAndSetter; + } + map[id] = newObj; + return newObj; +} +function retTimeout() { + return 'Timeout'; +} +function strToRegExp(str) { + var lastSlash = str.lastIndexOf('/'); + return new RegExp(str.slice(1, lastSlash), str.slice(lastSlash + 1)); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stripAnsi.js b/src/miniprogram_npm/miniprogram-licia/stripAnsi.js new file mode 100644 index 0000000..644e2af --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stripAnsi.js @@ -0,0 +1,6 @@ +var regAnsi = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g; +exports = function(str) { + return str.replace(regAnsi, ''); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stripBom.js b/src/miniprogram_npm/miniprogram-licia/stripBom.js new file mode 100644 index 0000000..cc9d1db --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stripBom.js @@ -0,0 +1,8 @@ +exports = function(str) { + if (str.charCodeAt(0) === 0xfeff) { + return str.slice(1); + } + return str; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stripCmt.js b/src/miniprogram_npm/miniprogram-licia/stripCmt.js new file mode 100644 index 0000000..dfca727 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stripCmt.js @@ -0,0 +1,56 @@ +exports = function(str) { + str = ('__' + str + '__').split(''); + var mode = { + singleQuote: false, + doubleQuote: false, + regex: false, + blockComment: false, + lineComment: false, + condComp: false + }; + for (var i = 0, l = str.length; i < l; i++) { + if (mode.regex) { + if (str[i] === '/' && str[i - 1] !== '\\') mode.regex = false; + continue; + } + if (mode.singleQuote) { + if (str[i] === "'" && str[i - 1] !== '\\') mode.singleQuote = false; + continue; + } + if (mode.doubleQuote) { + if (str[i] === '"' && str[i - 1] !== '\\') mode.doubleQuote = false; + continue; + } + if (mode.blockComment) { + if (str[i] === '*' && str[i + 1] === '/') { + str[i + 1] = ''; + mode.blockComment = false; + } + str[i] = ''; + continue; + } + if (mode.lineComment) { + if (str[i + 1] === '\n') mode.lineComment = false; + str[i] = ''; + continue; + } + mode.doubleQuote = str[i] === '"'; + mode.singleQuote = str[i] === "'"; + if (str[i] === '/') { + if (str[i + 1] === '*') { + str[i] = ''; + mode.blockComment = true; + continue; + } + if (str[i + 1] === '/') { + str[i] = ''; + mode.lineComment = true; + continue; + } + mode.regex = true; + } + } + return str.join('').slice(2, -2); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stripColor.js b/src/miniprogram_npm/miniprogram-licia/stripColor.js new file mode 100644 index 0000000..5a4bad3 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stripColor.js @@ -0,0 +1,6 @@ +var regColor = /\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]/g; +exports = function(str) { + return str.replace(regColor, ''); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stripHtmlTag.js b/src/miniprogram_npm/miniprogram-licia/stripHtmlTag.js new file mode 100644 index 0000000..1ad3095 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stripHtmlTag.js @@ -0,0 +1,6 @@ +var regHtmlTag = /<[^>]*>/g; +exports = function(str) { + return str.replace(regHtmlTag, ''); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stripIndent.js b/src/miniprogram_npm/miniprogram-licia/stripIndent.js new file mode 100644 index 0000000..0eeeac5 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stripIndent.js @@ -0,0 +1,40 @@ +var isStr = require('./isStr'); +var toArr = require('./toArr'); +var min = require('./min'); +var map = require('./map'); +var trim = require('./trim'); +exports = function(literals) { + if (isStr(literals)) literals = toArr(literals); + var str = ''; + for ( + var _len = arguments.length, + placeholders = new Array(_len > 1 ? _len - 1 : 0), + _key = 1; + _key < _len; + _key++ + ) { + placeholders[_key - 1] = arguments[_key]; + } + for (var i = 0, len = literals.length; i < len; i++) { + str += literals[i]; + if (placeholders[i]) str += placeholders[i]; + } + var lines = str.split('\n'); + var indentLens = []; + for (var _i = 0, _len2 = lines.length; _i < _len2; _i++) { + var line = lines[_i]; + var _indent = line.match(regStartSpaces); + if (_indent) { + indentLens.push(_indent[1].length); + } + } + var indent = indentLens.length > 0 ? min.apply(null, indentLens) : 0; + return trim( + map(lines, function(line) { + return line[0] === ' ' ? line.slice(indent) : line; + }).join('\n') + ); +}; +var regStartSpaces = /^(\s+)\S+/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/stripNum.js b/src/miniprogram_npm/miniprogram-licia/stripNum.js new file mode 100644 index 0000000..99da492 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/stripNum.js @@ -0,0 +1,7 @@ +exports = function(num) { + var precision = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 12; + return parseFloat(num.toPrecision(precision)); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/sum.js b/src/miniprogram_npm/miniprogram-licia/sum.js new file mode 100644 index 0000000..1f29302 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/sum.js @@ -0,0 +1,8 @@ +exports = function() { + var arr = arguments; + var ret = 0; + for (var i = 0, len = arr.length; i < len; i++) ret += arr[i]; + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/swap.js b/src/miniprogram_npm/miniprogram-licia/swap.js new file mode 100644 index 0000000..d0aec07 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/swap.js @@ -0,0 +1,8 @@ +exports = function(arr, a, b) { + var tmp = arr[a]; + arr[a] = arr[b]; + arr[b] = tmp; + return arr; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/table.js b/src/miniprogram_npm/miniprogram-licia/table.js new file mode 100644 index 0000000..8cf3bbe --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/table.js @@ -0,0 +1,118 @@ +var each = require('./each'); +var strWidth = require('./strWidth'); +var map = require('./map'); +var repeat = require('./repeat'); +var cloneDeep = require('./cloneDeep'); +exports = function(rows) { + rows = cloneDeep(rows); + var options = { + border: defBorder + }; + options.columns = getColumns(rows); + padData(rows, options); + return render(rows, options); +}; +function padData(rows, options) { + var columnCount = options.columns.length; + for (var i = 0, len = rows.length; i < len; i++) { + while (rows[i].length < columnCount) { + rows[i].push(''); + } + } + return loopData(rows, function(data, row, column) { + var _options$columns$colu = options.columns[column], + paddingLeft = _options$columns$colu.paddingLeft, + width = _options$columns$colu.width, + paddingRight = _options$columns$colu.paddingRight; + return ( + repeat(' ', paddingLeft) + + data + + repeat(' ', width - strWidth(data) - paddingRight) + ); + }); +} +function loopData(rows, handler) { + for (var i = 0, len = rows.length; i < len; i++) { + var row = rows[i]; + for (var j = 0, _len = row.length; j < _len; j++) { + var data = handler(row[j], i, j); + if (data) { + row[j] = data; + } + } + } +} +function getColumns(rows) { + var columns = []; + var paddingLeft = 1; + var paddingRight = 1; + loopData(rows, function(data, row, column) { + columns[column] = columns[column] || { + width: paddingLeft + paddingRight, + paddingLeft: paddingLeft, + paddingRight: paddingRight + }; + var width = strWidth(data) + paddingLeft + paddingRight; + if (width > columns[column].width) { + columns[column].width = width; + } + }); + return columns; +} +function render(rows, options) { + var ret = ''; + ret += renderBorder('top', options); + each(rows, function(row, idx) { + ret += renderRow(row, options); + if (idx === rows.length - 1) { + ret += renderBorder('bottom', options); + } else { + ret += renderBorder('join', options); + } + }); + return ret; +} +function renderRow(columns, options) { + var border = options.border; + return ( + border.bodyLeft + + columns.join(border.bodyJoin) + + border.bodyRight + + '\n' + ); +} +function renderBorder(type, options) { + var border = options.border, + columns = options.columns; + var left = border[type + 'Left']; + var right = border[type + 'Right']; + var body = border[type + 'Body']; + var join = border[type + 'Join']; + var ret = map(columns, function(column) { + return repeat(body, column.width); + }).join(join); + ret = left + ret + right; + if (type !== 'bottom') { + ret += '\n'; + } + return ret; +} +var defBorder = { + topBody: '─', + topJoin: '┬', + topLeft: '┌', + topRight: '┐', + bottomBody: '─', + bottomJoin: '┴', + bottomLeft: '└', + bottomRight: '┘', + bodyLeft: '│', + bodyRight: '│', + bodyJoin: '│', + joinBody: '─', + joinLeft: '├', + joinRight: '┤', + joinJoin: '┼' +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/throttle.js b/src/miniprogram_npm/miniprogram-licia/throttle.js new file mode 100644 index 0000000..c677095 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/throttle.js @@ -0,0 +1,6 @@ +var debounce = require('./debounce'); +exports = function(fn, wait) { + return debounce(fn, wait, true); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/timeAgo.js b/src/miniprogram_npm/miniprogram-licia/timeAgo.js new file mode 100644 index 0000000..c816c17 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/timeAgo.js @@ -0,0 +1,42 @@ +var isDate = require('./isDate'); +var toInt = require('./toInt'); +exports = function(date, now) { + if (!isDate(date)) date = new Date(date); + now = now || new Date(); + if (!isDate(now)) now = new Date(now); + var diff = (now - date) / 1000; + var i = 0; + var ago = diff > 0; + diff = Math.abs(diff); + while (diff >= secArr[i] && i < secArrLen) { + diff /= secArr[i]; + i++; + } + diff = toInt(diff); + i *= 2; + if (diff > (i === 0 ? 9 : 1)) i += 1; + return format(diff, i, ago); +}; +var secArr = [60, 60, 24, 7, 365 / 7 / 12, 12]; +var secArrLen = secArr.length; +function format(diff, i, ago) { + return exports.i18n[i][ago ? 0 : 1].replace('%s', diff); +} +exports.i18n = [ + ['just now', 'right now'], + ['%s seconds ago', 'in %s seconds'], + ['1 minute ago', 'in 1 minute'], + ['%s minutes ago', 'in %s minutes'], + ['1 hour ago', 'in 1 hour'], + ['%s hours ago', 'in %s hours'], + ['1 day ago', 'in 1 day'], + ['%s days ago', 'in %s days'], + ['1 week ago', 'in 1 week'], + ['%s weeks ago', 'in %s weeks'], + ['1 month ago', 'in 1 month'], + ['%s months ago', 'in %s months'], + ['1 year ago', 'in 1 year'], + ['%s years ago', 'in %s years'] +]; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/timeTaken.js b/src/miniprogram_npm/miniprogram-licia/timeTaken.js new file mode 100644 index 0000000..1e72933 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/timeTaken.js @@ -0,0 +1,8 @@ +var perfNow = require('./perfNow'); +exports = function(fn) { + var start = perfNow(); + fn(); + return perfNow() - start; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/times.js b/src/miniprogram_npm/miniprogram-licia/times.js new file mode 100644 index 0000000..8ca5132 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/times.js @@ -0,0 +1,11 @@ +var optimizeCb = require('./optimizeCb'); +exports = function(n, fn, ctx) { + var ret = Array(Math.max(0, n)); + fn = optimizeCb(fn, ctx, 1); + for (var i = 0; i < n; i++) { + ret[i] = fn(i); + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toArr.js b/src/miniprogram_npm/miniprogram-licia/toArr.js new file mode 100644 index 0000000..d115380 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toArr.js @@ -0,0 +1,12 @@ +var isArrLike = require('./isArrLike'); +var map = require('./map'); +var isArr = require('./isArr'); +var isStr = require('./isStr'); +exports = function(val) { + if (!val) return []; + if (isArr(val)) return val; + if (isArrLike(val) && !isStr(val)) return map(val); + return [val]; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toAsync.js b/src/miniprogram_npm/miniprogram-licia/toAsync.js new file mode 100644 index 0000000..d54fd85 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toAsync.js @@ -0,0 +1,52 @@ +var toArr = require('./toArr'); +var isGeneratorFn = require('./isGeneratorFn'); +var isPromise = require('./isPromise'); +var toStr = require('./toStr'); + +exports = function(fn) { + if (!isGeneratorFn(fn)) { + throw new TypeError('Expected a generator function'); + } + return function() { + var _this = this; + var args = toArr(arguments); + return new Promise(function(resolve, reject) { + var generator = fn.apply(_this, args); + function onFulfilled(res) { + var ret; + try { + ret = generator.next(res); + } catch (e) { + return reject(e); + } + next(ret); + } + function onRejected(err) { + var ret; + try { + ret = generator.throw(err); + } catch (e) { + return reject(e); + } + next(ret); + } + function next(ret) { + if (ret.done) return resolve(ret.value); + if (isPromise(ret.value)) { + return ret.value.then(onFulfilled, onRejected); + } + return onRejected( + new TypeError( + 'You may only yield a promise, '.concat( + toStr(ret.value), + ' is passed' + ) + ) + ); + } + onFulfilled(); + }); + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toBool.js b/src/miniprogram_npm/miniprogram-licia/toBool.js new file mode 100644 index 0000000..c92a8d4 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toBool.js @@ -0,0 +1,10 @@ +var isStr = require('./isStr'); +exports = function(val) { + if (isStr(val)) { + val = val.toLowerCase(); + return val !== '0' && val !== '' && val !== 'false'; + } + return !!val; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toDate.js b/src/miniprogram_npm/miniprogram-licia/toDate.js new file mode 100644 index 0000000..d599d75 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toDate.js @@ -0,0 +1,14 @@ +var isDate = require('./isDate'); +var isStr = require('./isStr'); +exports = function(val) { + if (!val) return new Date(); + if (isDate(val)) return val; + if (isStr(val)) { + var match = val.match(regDate); + if (match) return new Date(match[1], match[2] - 1, match[3]); + } + return new Date(val); +}; +var regDate = /^(\d{4})-?(\d{2})-?(\d{1,2})$/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toInt.js b/src/miniprogram_npm/miniprogram-licia/toInt.js new file mode 100644 index 0000000..6e6d49c --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toInt.js @@ -0,0 +1,8 @@ +var toNum = require('./toNum'); +exports = function(val) { + if (!val) return val === 0 ? val : 0; + val = toNum(val); + return val - (val % 1); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toNum.js b/src/miniprogram_npm/miniprogram-licia/toNum.js new file mode 100644 index 0000000..62bf36a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toNum.js @@ -0,0 +1,15 @@ +var isNum = require('./isNum'); +var isObj = require('./isObj'); +var isFn = require('./isFn'); +var isStr = require('./isStr'); +exports = function(val) { + if (isNum(val)) return val; + if (isObj(val)) { + var temp = isFn(val.valueOf) ? val.valueOf() : val; + val = isObj(temp) ? temp + '' : temp; + } + if (!isStr(val)) return val === 0 ? val : +val; + return +val; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toSrc.js b/src/miniprogram_npm/miniprogram-licia/toSrc.js new file mode 100644 index 0000000..89589e9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toSrc.js @@ -0,0 +1,14 @@ +var isNil = require('./isNil'); +exports = function(fn) { + if (isNil(fn)) return ''; + try { + return fnToStr.call(fn); + } catch (e) {} + try { + return fn + ''; + } catch (e) {} + return ''; +}; +var fnToStr = Function.prototype.toString; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/toStr.js b/src/miniprogram_npm/miniprogram-licia/toStr.js new file mode 100644 index 0000000..2c7e0c1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/toStr.js @@ -0,0 +1,5 @@ +exports = function(val) { + return val == null ? '' : val.toString(); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/topoSort.js b/src/miniprogram_npm/miniprogram-licia/topoSort.js new file mode 100644 index 0000000..8e53c8f --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/topoSort.js @@ -0,0 +1,43 @@ +exports = function(edges) { + return sort(uniqueNodes(edges), edges); +}; +function uniqueNodes(arr) { + var ret = []; + for (var i = 0, len = arr.length; i < len; i++) { + var edge = arr[i]; + if (ret.indexOf(edge[0]) < 0) ret.push(edge[0]); + if (ret.indexOf(edge[1]) < 0) ret.push(edge[1]); + } + return ret; +} +function sort(nodes, edges) { + var cursor = nodes.length; + var sorted = new Array(cursor); + var visited = {}; + var i = cursor; + while (i--) { + if (!visited[i]) visit(nodes[i], i, []); + } + function visit(node, i, predecessors) { + if (predecessors.indexOf(node) >= 0) { + throw new Error('Cyclic dependency: ' + JSON.stringify(node)); + } + if (visited[i]) return; + visited[i] = true; + var outgoing = edges.filter(function(edge) { + return edge[0] === node; + }); + + if ((i = outgoing.length)) { + var preds = predecessors.concat(node); + do { + var child = outgoing[--i][1]; + visit(child, nodes.indexOf(child), preds); + } while (i); + } + sorted[--cursor] = node; + } + return sorted; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/trim.js b/src/miniprogram_npm/miniprogram-licia/trim.js new file mode 100644 index 0000000..44eaa22 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/trim.js @@ -0,0 +1,10 @@ +var ltrim = require('./ltrim'); +var rtrim = require('./rtrim'); +exports = function(str, chars) { + if (chars == null && str.trim) { + return str.trim(); + } + return ltrim(rtrim(str, chars), chars); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/truncate.js b/src/miniprogram_npm/miniprogram-licia/truncate.js new file mode 100644 index 0000000..56bb3c7 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/truncate.js @@ -0,0 +1,27 @@ +var defaults = require('./defaults'); +var isUndef = require('./isUndef'); +exports = function(txt, width) { + var options = + arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + defaults(options, defOptions); + var ellipsis = options.ellipsis, + separator = options.separator; + var len = txt.length; + if (width > len) return txt; + var end = width - ellipsis.length; + if (end < 1) return ellipsis; + var ret = txt.slice(0, end); + if (isUndef(separator)) return ret + ellipsis; + if (txt.indexOf(separator, end) !== end) { + var idx = ret.lastIndexOf(separator); + if (idx > -1) { + ret = ret.slice(0, idx); + } + } + return ret + ellipsis; +}; +var defOptions = { + ellipsis: '...' +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/tryIt.js b/src/miniprogram_npm/miniprogram-licia/tryIt.js new file mode 100644 index 0000000..d079d01 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/tryIt.js @@ -0,0 +1,12 @@ +var noop = require('./noop'); +exports = function(fn, cb) { + cb = cb || noop; + try { + cb(null, fn()); + } catch (e) { + cb(e); + return; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/type.js b/src/miniprogram_npm/miniprogram-licia/type.js new file mode 100644 index 0000000..733f2cc --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/type.js @@ -0,0 +1,24 @@ +var objToStr = require('./objToStr'); +var isNaN = require('./isNaN'); +var lowerCase = require('./lowerCase'); +var isBuffer = require('./isBuffer'); +exports = function(val) { + var lower = + arguments.length > 1 && arguments[1] !== undefined + ? arguments[1] + : true; + var ret; + if (val === null) ret = 'Null'; + if (val === undefined) ret = 'Undefined'; + if (isNaN(val)) ret = 'NaN'; + if (isBuffer(val)) ret = 'Buffer'; + if (!ret) { + ret = objToStr(val).match(regObj); + if (ret) ret = ret[1]; + } + if (!ret) return ''; + return lower ? lowerCase(ret) : ret; +}; +var regObj = /^\[object\s+(.*?)]$/; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/types.js b/src/miniprogram_npm/miniprogram-licia/types.js new file mode 100644 index 0000000..de9c910 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/types.js @@ -0,0 +1,3 @@ +exports = {}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/ucs2.js b/src/miniprogram_npm/miniprogram-licia/ucs2.js new file mode 100644 index 0000000..e4da234 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/ucs2.js @@ -0,0 +1,37 @@ +var chunk = require('./chunk'); +var map = require('./map'); + +exports = { + encode: function(arr) { + if (arr.length < 32768) { + return String.fromCodePoint.apply(String, arr); + } + return map(chunk(arr, 32767), function(nums) { + return String.fromCodePoint.apply(String, nums); + }).join(''); + }, + decode: function(str) { + var ret = []; + var i = 0; + var len = str.length; + while (i < len) { + var c = str.charCodeAt(i++); + + if (c >= 0xd800 && c <= 0xdbff && i < len) { + var tail = str.charCodeAt(i++); + + if ((tail & 0xfc00) === 0xdc00) { + ret.push(((c & 0x3ff) << 10) + (tail & 0x3ff) + 0x10000); + } else { + ret.push(c); + i--; + } + } else { + ret.push(c); + } + } + return ret; + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/unescape.js b/src/miniprogram_npm/miniprogram-licia/unescape.js new file mode 100644 index 0000000..84abd2d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/unescape.js @@ -0,0 +1,15 @@ +var escape = require('./escape'); +var keys = require('./keys'); +var invert = require('./invert'); +exports = function(str) { + return regTest.test(str) ? str.replace(regReplace, replaceFn) : str; +}; +var map = invert(escape.map); +var regSrc = '(?:' + keys(map).join('|') + ')'; +var regTest = new RegExp(regSrc); +var regReplace = new RegExp(regSrc, 'g'); +function replaceFn(match) { + return map[match]; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/union.js b/src/miniprogram_npm/miniprogram-licia/union.js new file mode 100644 index 0000000..9b01f17 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/union.js @@ -0,0 +1,8 @@ +var restArgs = require('./restArgs'); +var unique = require('./unique'); +var flatten = require('./flatten'); +exports = restArgs(function(arrays) { + return unique(flatten(arrays)); +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/uniqId.js b/src/miniprogram_npm/miniprogram-licia/uniqId.js new file mode 100644 index 0000000..804bb48 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/uniqId.js @@ -0,0 +1,7 @@ +var idCounter = 0; +exports = function(prefix) { + var id = ++idCounter + ''; + return prefix ? prefix + id : id; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/unique.js b/src/miniprogram_npm/miniprogram-licia/unique.js new file mode 100644 index 0000000..8aa676e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/unique.js @@ -0,0 +1,16 @@ +var filter = require('./filter'); +exports = function(arr, cmp) { + cmp = cmp || isEqual; + return filter(arr, function(item, idx, arr) { + var len = arr.length; + while (++idx < len) { + if (cmp(item, arr[idx])) return false; + } + return true; + }); +}; +function isEqual(a, b) { + return a === b; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/universalify.js b/src/miniprogram_npm/miniprogram-licia/universalify.js new file mode 100644 index 0000000..c35b214 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/universalify.js @@ -0,0 +1,31 @@ +var promisify = require('./promisify'); +var callbackify = require('./callbackify'); +var last = require('./last'); +var isFn = require('./isFn'); +exports = function(fn, type) { + var callbackFn; + var promiseFn; + if (type === 'callback') { + callbackFn = fn; + promiseFn = promisify(fn); + } else { + promiseFn = fn; + callbackFn = callbackify(fn); + } + return function() { + for ( + var _len = arguments.length, args = new Array(_len), _key = 0; + _key < _len; + _key++ + ) { + args[_key] = arguments[_key]; + } + if (isFn(last(args))) { + callbackFn.apply(this, args); + } else { + return promiseFn.apply(this, args); + } + }; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/unzip.js b/src/miniprogram_npm/miniprogram-licia/unzip.js new file mode 100644 index 0000000..c12c83a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/unzip.js @@ -0,0 +1,18 @@ +var map = require('./map'); +var pluck = require('./pluck'); +var max = require('./max'); +exports = function(arr) { + var len = max.apply( + null, + map(arr, function(arr) { + return arr.length; + }) + ); + var ret = Array(len); + for (var i = 0; i < len; i++) { + ret[i] = pluck(arr, i); + } + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/upperCase.js b/src/miniprogram_npm/miniprogram-licia/upperCase.js new file mode 100644 index 0000000..cf2c9c9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/upperCase.js @@ -0,0 +1,6 @@ +var toStr = require('./toStr'); +exports = function(str) { + return toStr(str).toLocaleUpperCase(); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/upperFirst.js b/src/miniprogram_npm/miniprogram-licia/upperFirst.js new file mode 100644 index 0000000..c4a3d54 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/upperFirst.js @@ -0,0 +1,6 @@ +exports = function(str) { + if (str.length < 1) return str; + return str[0].toUpperCase() + str.slice(1); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/use.js b/src/miniprogram_npm/miniprogram-licia/use.js new file mode 100644 index 0000000..55cdd31 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/use.js @@ -0,0 +1,29 @@ +var map = require('./map'); +var define = require('./define'); +var has = require('./has'); +var toArr = require('./toArr'); +exports = function(requires, method) { + if (method == null) { + method = requires; + requires = []; + } + requires = map(toArr(requires), function(val) { + return req(val); + }); + method.apply(null, requires); +}; +var modules = define._modules; +var requireMarks = {}; +function req(name) { + if (has(requireMarks, name)) return modules[name]; + var requires = modules[name].requires; + var body = modules[name].body; + var len = requires.length; + for (var i = 0; i < len; i++) requires[i] = req(requires[i]); + var exports = body.apply(null, requires); + if (exports) modules[name] = exports; + requireMarks[name] = true; + return modules[name]; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/utf8.js b/src/miniprogram_npm/miniprogram-licia/utf8.js new file mode 100644 index 0000000..9c88c8b --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/utf8.js @@ -0,0 +1,127 @@ +var ucs2 = require('./ucs2'); + +exports = { + encode: function(str) { + var codePoints = ucs2.decode(str); + var byteArr = ''; + for (var i = 0, len = codePoints.length; i < len; i++) { + byteArr += encodeCodePoint(codePoints[i]); + } + return byteArr; + }, + decode: function(str, safe) { + byteArr = ucs2.decode(str); + byteIdx = 0; + byteCount = byteArr.length; + codePoint = 0; + bytesSeen = 0; + bytesNeeded = 0; + lowerBoundary = 0x80; + upperBoundary = 0xbf; + var codePoints = []; + var tmp; + while ((tmp = decodeCodePoint(safe)) !== false) { + codePoints.push(tmp); + } + return ucs2.encode(codePoints); + } +}; +var fromCharCode = String.fromCharCode; +function encodeCodePoint(codePoint) { + if ((codePoint & 0xffffff80) === 0) { + return fromCharCode(codePoint); + } + var ret = '', + count, + offset; + + if ((codePoint & 0xfffff800) === 0) { + count = 1; + offset = 0xc0; + } else if ((codePoint & 0xffff0000) === 0) { + count = 2; + offset = 0xe0; + } else if ((codePoint & 0xffe00000) == 0) { + count = 3; + offset = 0xf0; + } + ret += fromCharCode((codePoint >> (6 * count)) + offset); + while (count > 0) { + var tmp = codePoint >> (6 * (count - 1)); + ret += fromCharCode(0x80 | (tmp & 0x3f)); + count--; + } + return ret; +} +var byteArr, + byteIdx, + byteCount, + codePoint, + bytesSeen, + bytesNeeded, + lowerBoundary, + upperBoundary; +function decodeCodePoint(safe) { + while (true) { + if (byteIdx >= byteCount && bytesNeeded) { + if (safe) return goBack(); + throw new Error('Invalid byte index'); + } + if (byteIdx === byteCount) return false; + var byte = byteArr[byteIdx]; + byteIdx++; + if (!bytesNeeded) { + if ((byte & 0x80) === 0) { + return byte; + } + + if ((byte & 0xe0) === 0xc0) { + bytesNeeded = 1; + codePoint = byte & 0x1f; + } else if ((byte & 0xf0) === 0xe0) { + if (byte === 0xe0) lowerBoundary = 0xa0; + if (byte === 0xed) upperBoundary = 0x9f; + bytesNeeded = 2; + codePoint = byte & 0xf; + } else if ((byte & 0xf8) === 0xf0) { + if (byte === 0xf0) lowerBoundary = 0x90; + if (byte === 0xf4) upperBoundary = 0x8f; + bytesNeeded = 3; + codePoint = byte & 0x7; + } else { + if (safe) return goBack(); + throw new Error('Invalid UTF-8 detected'); + } + continue; + } + if (byte < lowerBoundary || byte > upperBoundary) { + if (safe) { + byteIdx--; + return goBack(); + } + throw new Error('Invalid continuation byte'); + } + lowerBoundary = 0x80; + upperBoundary = 0xbf; + codePoint = (codePoint << 6) | (byte & 0x3f); + bytesSeen++; + if (bytesSeen !== bytesNeeded) continue; + var tmp = codePoint; + codePoint = 0; + bytesNeeded = 0; + bytesSeen = 0; + return tmp; + } +} +function goBack() { + var start = byteIdx - bytesSeen - 1; + byteIdx = start + 1; + codePoint = 0; + bytesNeeded = 0; + bytesSeen = 0; + lowerBoundary = 0x80; + upperBoundary = 0xbf; + return byteArr[start]; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/uuid.js b/src/miniprogram_npm/miniprogram-licia/uuid.js new file mode 100644 index 0000000..446951d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/uuid.js @@ -0,0 +1,34 @@ +var randomBytes = require('./randomBytes'); +exports = function() { + var b = randomBytes(16); + b[6] = (b[6] & 0x0f) | 0x40; + b[8] = (b[8] & 0x3f) | 0x80; + return ( + hexBytes[b[0]] + + hexBytes[b[1]] + + hexBytes[b[2]] + + hexBytes[b[3]] + + '-' + + hexBytes[b[4]] + + hexBytes[b[5]] + + '-' + + hexBytes[b[6]] + + hexBytes[b[7]] + + '-' + + hexBytes[b[8]] + + hexBytes[b[9]] + + '-' + + hexBytes[b[10]] + + hexBytes[b[11]] + + hexBytes[b[12]] + + hexBytes[b[13]] + + hexBytes[b[14]] + + hexBytes[b[15]] + ); +}; +var hexBytes = []; +for (var i = 0; i < 256; i++) { + hexBytes[i] = (i + 0x100).toString(16).substr(1); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/values.js b/src/miniprogram_npm/miniprogram-licia/values.js new file mode 100644 index 0000000..985989e --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/values.js @@ -0,0 +1,10 @@ +var each = require('./each'); +exports = function(obj) { + var ret = []; + each(obj, function(val) { + ret.push(val); + }); + return ret; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/vlq.js b/src/miniprogram_npm/miniprogram-licia/vlq.js new file mode 100644 index 0000000..71e5c5d --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/vlq.js @@ -0,0 +1,69 @@ +var toArr = require('./toArr'); + +exports = { + encode: function(arr) { + arr = toArr(arr); + var ret = ''; + for (var i = 0, len = arr.length; i < len; i++) { + ret += encode(arr[i]); + } + return ret; + }, + decode: function(str) { + var ret = []; + var i = 0; + var len = str.length; + while (i < len) { + var value = 0; + var continuation = false; + var shift = 0; + do { + var digit = charToInt[str[i++]]; + continuation = (digit & VLQ_CONTINUATION_BIT) !== 0; + digit &= VLQ_BASE_MASK; + value = value + (digit << shift); + shift = shift + VLQ_BASE_SHIFT; + } while (continuation); + ret.push(fromVLQSigned(value)); + } + return ret; + } +}; +var charToInt = {}; +var intToChar = {}; +var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; +for (var i = 0, len = chars.length; i < len; i++) { + charToInt[chars[i]] = i; + intToChar[i] = chars[i]; +} +var VLQ_BASE_SHIFT = 5; +var VLQ_BASE = 1 << VLQ_BASE_SHIFT; +var VLQ_BASE_MASK = VLQ_BASE - 1; +var VLQ_CONTINUATION_BIT = VLQ_BASE; +function encode(value) { + var ret = ''; + value = toVLQSigned(value); + do { + var digit = value & VLQ_BASE_MASK; + value >>>= VLQ_BASE_SHIFT; + if (value > 0) { + digit |= VLQ_CONTINUATION_BIT; + } + ret += intToChar[digit]; + } while (value > 0); + return ret; +} +function toVLQSigned(value) { + if (value < 0) { + return (-value << 1) + 1; + } else { + return (value << 1) + 0; + } +} +function fromVLQSigned(value) { + var negate = (value & 1) === 1; + value = value >> 1; + return negate ? -value : value; +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/waitUntil.js b/src/miniprogram_npm/miniprogram-licia/waitUntil.js new file mode 100644 index 0000000..5e724e9 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/waitUntil.js @@ -0,0 +1,36 @@ +var now = require('./now'); +exports = function(condition) { + var timeout = + arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var interval = + arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 250; + function evalCondition() { + return new Promise(function(resolve, reject) { + try { + resolve(condition()); + } catch (e) { + reject(e); + } + }); + } + return new Promise(function(resolve, reject) { + var startTime = now(); + var pollCondition = function() { + evalCondition().then(function(val) { + var elapsed = now() - startTime; + if (val) { + resolve(val); + } else if (timeout && elapsed >= timeout) { + reject( + Error('Wait timed out after '.concat(timeout, ' ms')) + ); + } else { + setTimeout(pollCondition, interval); + } + }, reject); + }; + pollCondition(); + }); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/waterfall.js b/src/miniprogram_npm/miniprogram-licia/waterfall.js new file mode 100644 index 0000000..8f11c48 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/waterfall.js @@ -0,0 +1,27 @@ +var noop = require('./noop'); +var nextTick = require('./nextTick'); +var restArgs = require('./restArgs'); +exports = function(tasks, cb) { + cb = cb || noop; + var current = 0; + var taskCb = restArgs(function(err, args) { + if (++current >= tasks.length || err) { + args.unshift(err); + nextTick(function() { + cb.apply(null, args); + }); + } else { + args.push(taskCb); + tasks[current].apply(null, args); + } + }); + if (tasks.length) { + tasks[0](taskCb); + } else { + nextTick(function() { + cb(); + }); + } +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/wordWrap.js b/src/miniprogram_npm/miniprogram-licia/wordWrap.js new file mode 100644 index 0000000..04713ed --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/wordWrap.js @@ -0,0 +1,49 @@ +var map = require('./map'); +var reduce = require('./reduce'); +var concat = require('./concat'); +var last = require('./last'); +var trim = require('./trim'); +exports = function(txt, width) { + var lines = txt.split('\n'); + return map(lines, function(line) { + return wrap(line, width); + }).join('\n'); +}; +var regWordBoundary = /(\S+\s+)/; +function wrap(txt, width) { + var chunks = reduce( + txt.split(regWordBoundary), + function(chunks, word) { + if (trim(word) === '') return chunks; + if (word.length > width) { + chunks = concat( + chunks, + word.match(new RegExp('.{1,'.concat(width, '}'), 'g')) + ); + } else { + chunks.push(word); + } + return chunks; + }, + [] + ); + var lines = reduce( + chunks, + function(lines, chunk) { + var lastLine = last(lines); + if (lastLine.length + chunk.length > width) { + if (trim(lastLine) === '') { + lines.pop(); + } + lines.push(chunk); + } else { + lines[lines.length - 1] = lastLine + chunk; + } + return lines; + }, + [chunks.shift()] + ); + return lines.join('\n'); +} + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/wordsToBytes.js b/src/miniprogram_npm/miniprogram-licia/wordsToBytes.js new file mode 100644 index 0000000..c3b9e22 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/wordsToBytes.js @@ -0,0 +1,9 @@ +exports = function(words) { + var bytes = []; + for (var b = 0, len = words.length * 32; b < len; b += 8) { + bytes.push((words[b >>> 5] >>> (24 - (b % 32))) & 0xff); + } + return bytes; +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/wrap.js b/src/miniprogram_npm/miniprogram-licia/wrap.js new file mode 100644 index 0000000..e6ad71a --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/wrap.js @@ -0,0 +1,6 @@ +var partial = require('./partial'); +exports = function(fn, wrapper) { + return partial(wrapper, fn); +}; + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/wx.js b/src/miniprogram_npm/miniprogram-licia/wx.js new file mode 100644 index 0000000..d6d50d1 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/wx.js @@ -0,0 +1,69 @@ +var each = require('./each'); +var arrToMap = require('./arrToMap'); +var startWith = require('./startWith'); +var endWith = require('./endWith'); +var extend = require('./extend'); + +var noPromiseMethods = arrToMap([ + 'stopRecord', + 'getRecorderManager', + 'pauseVoice', + 'stopVoice', + 'pauseBackgroundAudio', + 'stopBackgroundAudio', + 'getBackgroundAudioManager', + 'createAudioContext', + 'createInnerAudioContext', + 'createVideoContext', + 'createCameraContext', + 'createMapContext', + 'canIUse', + 'startAccelerometer', + 'stopAccelerometer', + 'startCompass', + 'stopCompass', + 'onBLECharacteristicValueChange', + 'onBLEConnectionStateChange', + 'hideToast', + 'hideLoading', + 'showNavigationBarLoading', + 'hideNavigationBarLoading', + 'navigateBack', + 'createAnimation', + 'pageScrollTo', + 'createSelectorQuery', + 'createCanvasContext', + 'createContext', + 'drawCanvas', + 'hideKeyboard', + 'stopPullDownRefresh', + 'arrayBufferToBase64', + 'base64ToArrayBuffer' +]); +function needToPromisify(name) { + return ( + !noPromiseMethods[name] && + !startWith(name, 'on') && + !endWith(name, 'Sync') + ); +} +each(wx, function(fn, name) { + if (!needToPromisify(name)) return; + exports[name] = function(obj) { + return new Promise(function(resolve, reject) { + fn.call( + wx, + extend(obj, { + success: function(res) { + resolve(res); + }, + fail: function(res) { + reject(res); + } + }) + ); + }); + }; +}); + +module.exports = exports; diff --git a/src/miniprogram_npm/miniprogram-licia/zip.js b/src/miniprogram_npm/miniprogram-licia/zip.js new file mode 100644 index 0000000..1f96866 --- /dev/null +++ b/src/miniprogram_npm/miniprogram-licia/zip.js @@ -0,0 +1,5 @@ +var restArgs = require('./restArgs'); +var unzip = require('./unzip'); +exports = restArgs(unzip); + +module.exports = exports; diff --git a/src/utils/request.ts b/src/utils/request.ts new file mode 100644 index 0000000..241fa4e --- /dev/null +++ b/src/utils/request.ts @@ -0,0 +1,92 @@ +interface IGlobalParams { + gUrl: string; +} + +interface IAgaxParams extends WechatMiniprogram.RequestOption { + showMsg?: boolean; + loading?: boolean; + isJSON?: boolean; +} + +export const request = function ( + { gUrl }: IGlobalParams, + { + url, + method, + data, + header, + showMsg = true, + loading = false, + isJSON = false, + ...options + }: IAgaxParams, +): Promise { + return new Promise((resolve, reject) => { + if (loading) { + wx.showLoading({ + title: "加载中...", + mask: true, + }); + } + wx.request({ + header: { + loginState: getApp().globalData.loginState, + ...header, + }, + url: gUrl + url, + method: method, + data: { + loginState: getApp().globalData.loginState, + ...(data as object), + }, + ...options, + success(res: any) { + const { code, data } = res.data; + if (isJSON) { + resolve(res.data); + } else if (code === 0) { + resolve(data); + } else if (showMsg) { + const msg = errPicker(res.data); + if (loading) { + setTimeout(() => { + wx.showToast({ + title: msg, + icon: "none", + }); + }, 30); + } else { + wx.showToast({ + title: msg, + icon: "none", + }); + reject(res); + } + } else { + reject(res); + } + }, + fail(err) { + reject(err); + }, + complete() { + if (loading) { + wx.hideLoading(); + } + }, + }); + }); +}; + +function errPicker(err: any) { + if (typeof err === "string") { + return err; + } + return ( + err.data || + err.msg || + err.errMsg || + (err.detail && err.detail.errMsg) || + "未知错误" + ); +} diff --git a/typings/index.d.ts b/typings/index.d.ts index f495b12..a123f58 100644 --- a/typings/index.d.ts +++ b/typings/index.d.ts @@ -3,7 +3,16 @@ interface IAppOption { globalData: { userInfo?: WechatMiniprogram.UserInfo; + url: string; + upFileUrl: string; + imageUrl: string; }; userInfoReadyCallback?: WechatMiniprogram.GetUserInfoSuccessCallback; waitLogin(): Promise; } + +declare namespace WechatMiniprogram { + export interface Wx { + ajax: ({}) => Promise; + } +}