office-viewer 0.3.13 → 0.3.15

package/esm/node_modules/zrender/lib/core/BoundingRect.js

@@ -1,218 +0,0 @@
-import { translate, scale, create } from './matrix.js';
-import Point from './Point.js';
-
-var mathMin = Math.min;
-var mathMax = Math.max;
-var lt = new Point();
-var rb = new Point();
-var lb = new Point();
-var rt = new Point();
-var minTv = new Point();
-var maxTv = new Point();
-var BoundingRect = (function () {
-    function BoundingRect(x, y, width, height) {
-        if (width < 0) {
-            x = x + width;
-            width = -width;
-        }
-        if (height < 0) {
-            y = y + height;
-            height = -height;
-        }
-        this.x = x;
-        this.y = y;
-        this.width = width;
-        this.height = height;
-    }
-    BoundingRect.prototype.union = function (other) {
-        var x = mathMin(other.x, this.x);
-        var y = mathMin(other.y, this.y);
-        if (isFinite(this.x) && isFinite(this.width)) {
-            this.width = mathMax(other.x + other.width, this.x + this.width) - x;
-        }
-        else {
-            this.width = other.width;
-        }
-        if (isFinite(this.y) && isFinite(this.height)) {
-            this.height = mathMax(other.y + other.height, this.y + this.height) - y;
-        }
-        else {
-            this.height = other.height;
-        }
-        this.x = x;
-        this.y = y;
-    };
-    BoundingRect.prototype.applyTransform = function (m) {
-        BoundingRect.applyTransform(this, this, m);
-    };
-    BoundingRect.prototype.calculateTransform = function (b) {
-        var a = this;
-        var sx = b.width / a.width;
-        var sy = b.height / a.height;
-        var m = create();
-        translate(m, m, [-a.x, -a.y]);
-        scale(m, m, [sx, sy]);
-        translate(m, m, [b.x, b.y]);
-        return m;
-    };
-    BoundingRect.prototype.intersect = function (b, mtv) {
-        if (!b) {
-            return false;
-        }
-        if (!(b instanceof BoundingRect)) {
-            b = BoundingRect.create(b);
-        }
-        var a = this;
-        var ax0 = a.x;
-        var ax1 = a.x + a.width;
-        var ay0 = a.y;
-        var ay1 = a.y + a.height;
-        var bx0 = b.x;
-        var bx1 = b.x + b.width;
-        var by0 = b.y;
-        var by1 = b.y + b.height;
-        var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
-        if (mtv) {
-            var dMin = Infinity;
-            var dMax = 0;
-            var d0 = Math.abs(ax1 - bx0);
-            var d1 = Math.abs(bx1 - ax0);
-            var d2 = Math.abs(ay1 - by0);
-            var d3 = Math.abs(by1 - ay0);
-            var dx = Math.min(d0, d1);
-            var dy = Math.min(d2, d3);
-            if (ax1 < bx0 || bx1 < ax0) {
-                if (dx > dMax) {
-                    dMax = dx;
-                    if (d0 < d1) {
-                        Point.set(maxTv, -d0, 0);
-                    }
-                    else {
-                        Point.set(maxTv, d1, 0);
-                    }
-                }
-            }
-            else {
-                if (dx < dMin) {
-                    dMin = dx;
-                    if (d0 < d1) {
-                        Point.set(minTv, d0, 0);
-                    }
-                    else {
-                        Point.set(minTv, -d1, 0);
-                    }
-                }
-            }
-            if (ay1 < by0 || by1 < ay0) {
-                if (dy > dMax) {
-                    dMax = dy;
-                    if (d2 < d3) {
-                        Point.set(maxTv, 0, -d2);
-                    }
-                    else {
-                        Point.set(maxTv, 0, d3);
-                    }
-                }
-            }
-            else {
-                if (dx < dMin) {
-                    dMin = dx;
-                    if (d2 < d3) {
-                        Point.set(minTv, 0, d2);
-                    }
-                    else {
-                        Point.set(minTv, 0, -d3);
-                    }
-                }
-            }
-        }
-        if (mtv) {
-            Point.copy(mtv, overlap ? minTv : maxTv);
-        }
-        return overlap;
-    };
-    BoundingRect.prototype.contain = function (x, y) {
-        var rect = this;
-        return x >= rect.x
-            && x <= (rect.x + rect.width)
-            && y >= rect.y
-            && y <= (rect.y + rect.height);
-    };
-    BoundingRect.prototype.clone = function () {
-        return new BoundingRect(this.x, this.y, this.width, this.height);
-    };
-    BoundingRect.prototype.copy = function (other) {
-        BoundingRect.copy(this, other);
-    };
-    BoundingRect.prototype.plain = function () {
-        return {
-            x: this.x,
-            y: this.y,
-            width: this.width,
-            height: this.height
-        };
-    };
-    BoundingRect.prototype.isFinite = function () {
-        return isFinite(this.x)
-            && isFinite(this.y)
-            && isFinite(this.width)
-            && isFinite(this.height);
-    };
-    BoundingRect.prototype.isZero = function () {
-        return this.width === 0 || this.height === 0;
-    };
-    BoundingRect.create = function (rect) {
-        return new BoundingRect(rect.x, rect.y, rect.width, rect.height);
-    };
-    BoundingRect.copy = function (target, source) {
-        target.x = source.x;
-        target.y = source.y;
-        target.width = source.width;
-        target.height = source.height;
-    };
-    BoundingRect.applyTransform = function (target, source, m) {
-        if (!m) {
-            if (target !== source) {
-                BoundingRect.copy(target, source);
-            }
-            return;
-        }
-        if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) {
-            var sx = m[0];
-            var sy = m[3];
-            var tx = m[4];
-            var ty = m[5];
-            target.x = source.x * sx + tx;
-            target.y = source.y * sy + ty;
-            target.width = source.width * sx;
-            target.height = source.height * sy;
-            if (target.width < 0) {
-                target.x += target.width;
-                target.width = -target.width;
-            }
-            if (target.height < 0) {
-                target.y += target.height;
-                target.height = -target.height;
-            }
-            return;
-        }
-        lt.x = lb.x = source.x;
-        lt.y = rt.y = source.y;
-        rb.x = rt.x = source.x + source.width;
-        rb.y = lb.y = source.y + source.height;
-        lt.transform(m);
-        rt.transform(m);
-        rb.transform(m);
-        lb.transform(m);
-        target.x = mathMin(lt.x, rb.x, lb.x, rt.x);
-        target.y = mathMin(lt.y, rb.y, lb.y, rt.y);
-        var maxX = mathMax(lt.x, rb.x, lb.x, rt.x);
-        var maxY = mathMax(lt.y, rb.y, lb.y, rt.y);
-        target.width = maxX - target.x;
-        target.height = maxY - target.y;
-    };
-    return BoundingRect;
-}());
-var BoundingRect$1 = BoundingRect;
-
-export { BoundingRect$1 as default };

package/esm/node_modules/zrender/lib/core/Eventful.js

@@ -1,164 +0,0 @@
-var Eventful = (function () {
-    function Eventful(eventProcessors) {
-        if (eventProcessors) {
-            this._$eventProcessor = eventProcessors;
-        }
-    }
-    Eventful.prototype.on = function (event, query, handler, context) {
-        if (!this._$handlers) {
-            this._$handlers = {};
-        }
-        var _h = this._$handlers;
-        if (typeof query === 'function') {
-            context = handler;
-            handler = query;
-            query = null;
-        }
-        if (!handler || !event) {
-            return this;
-        }
-        var eventProcessor = this._$eventProcessor;
-        if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
-            query = eventProcessor.normalizeQuery(query);
-        }
-        if (!_h[event]) {
-            _h[event] = [];
-        }
-        for (var i = 0; i < _h[event].length; i++) {
-            if (_h[event][i].h === handler) {
-                return this;
-            }
-        }
-        var wrap = {
-            h: handler,
-            query: query,
-            ctx: (context || this),
-            callAtLast: handler.zrEventfulCallAtLast
-        };
-        var lastIndex = _h[event].length - 1;
-        var lastWrap = _h[event][lastIndex];
-        (lastWrap && lastWrap.callAtLast)
-            ? _h[event].splice(lastIndex, 0, wrap)
-            : _h[event].push(wrap);
-        return this;
-    };
-    Eventful.prototype.isSilent = function (eventName) {
-        var _h = this._$handlers;
-        return !_h || !_h[eventName] || !_h[eventName].length;
-    };
-    Eventful.prototype.off = function (eventType, handler) {
-        var _h = this._$handlers;
-        if (!_h) {
-            return this;
-        }
-        if (!eventType) {
-            this._$handlers = {};
-            return this;
-        }
-        if (handler) {
-            if (_h[eventType]) {
-                var newList = [];
-                for (var i = 0, l = _h[eventType].length; i < l; i++) {
-                    if (_h[eventType][i].h !== handler) {
-                        newList.push(_h[eventType][i]);
-                    }
-                }
-                _h[eventType] = newList;
-            }
-            if (_h[eventType] && _h[eventType].length === 0) {
-                delete _h[eventType];
-            }
-        }
-        else {
-            delete _h[eventType];
-        }
-        return this;
-    };
-    Eventful.prototype.trigger = function (eventType) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        if (!this._$handlers) {
-            return this;
-        }
-        var _h = this._$handlers[eventType];
-        var eventProcessor = this._$eventProcessor;
-        if (_h) {
-            var argLen = args.length;
-            var len = _h.length;
-            for (var i = 0; i < len; i++) {
-                var hItem = _h[i];
-                if (eventProcessor
-                    && eventProcessor.filter
-                    && hItem.query != null
-                    && !eventProcessor.filter(eventType, hItem.query)) {
-                    continue;
-                }
-                switch (argLen) {
-                    case 0:
-                        hItem.h.call(hItem.ctx);
-                        break;
-                    case 1:
-                        hItem.h.call(hItem.ctx, args[0]);
-                        break;
-                    case 2:
-                        hItem.h.call(hItem.ctx, args[0], args[1]);
-                        break;
-                    default:
-                        hItem.h.apply(hItem.ctx, args);
-                        break;
-                }
-            }
-        }
-        eventProcessor && eventProcessor.afterTrigger
-            && eventProcessor.afterTrigger(eventType);
-        return this;
-    };
-    Eventful.prototype.triggerWithContext = function (type) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        if (!this._$handlers) {
-            return this;
-        }
-        var _h = this._$handlers[type];
-        var eventProcessor = this._$eventProcessor;
-        if (_h) {
-            var argLen = args.length;
-            var ctx = args[argLen - 1];
-            var len = _h.length;
-            for (var i = 0; i < len; i++) {
-                var hItem = _h[i];
-                if (eventProcessor
-                    && eventProcessor.filter
-                    && hItem.query != null
-                    && !eventProcessor.filter(type, hItem.query)) {
-                    continue;
-                }
-                switch (argLen) {
-                    case 0:
-                        hItem.h.call(ctx);
-                        break;
-                    case 1:
-                        hItem.h.call(ctx, args[0]);
-                        break;
-                    case 2:
-                        hItem.h.call(ctx, args[0], args[1]);
-                        break;
-                    default:
-                        hItem.h.apply(ctx, args.slice(1, argLen - 1));
-                        break;
-                }
-            }
-        }
-        eventProcessor && eventProcessor.afterTrigger
-            && eventProcessor.afterTrigger(type);
-        return this;
-    };
-    return Eventful;
-}());
-var Eventful$1 = Eventful;
-
-export { Eventful$1 as default };

package/esm/node_modules/zrender/lib/core/GestureMgr.js

@@ -1,84 +0,0 @@
-import { clientToLocal } from './event.js';
-
-var GestureMgr = (function () {
-    function GestureMgr() {
-        this._track = [];
-    }
-    GestureMgr.prototype.recognize = function (event, target, root) {
-        this._doTrack(event, target, root);
-        return this._recognize(event);
-    };
-    GestureMgr.prototype.clear = function () {
-        this._track.length = 0;
-        return this;
-    };
-    GestureMgr.prototype._doTrack = function (event, target, root) {
-        var touches = event.touches;
-        if (!touches) {
-            return;
-        }
-        var trackItem = {
-            points: [],
-            touches: [],
-            target: target,
-            event: event
-        };
-        for (var i = 0, len = touches.length; i < len; i++) {
-            var touch = touches[i];
-            var pos = clientToLocal(root, touch, {});
-            trackItem.points.push([pos.zrX, pos.zrY]);
-            trackItem.touches.push(touch);
-        }
-        this._track.push(trackItem);
-    };
-    GestureMgr.prototype._recognize = function (event) {
-        for (var eventName in recognizers) {
-            if (recognizers.hasOwnProperty(eventName)) {
-                var gestureInfo = recognizers[eventName](this._track, event);
-                if (gestureInfo) {
-                    return gestureInfo;
-                }
-            }
-        }
-    };
-    return GestureMgr;
-}());
-function dist(pointPair) {
-    var dx = pointPair[1][0] - pointPair[0][0];
-    var dy = pointPair[1][1] - pointPair[0][1];
-    return Math.sqrt(dx * dx + dy * dy);
-}
-function center(pointPair) {
-    return [
-        (pointPair[0][0] + pointPair[1][0]) / 2,
-        (pointPair[0][1] + pointPair[1][1]) / 2
-    ];
-}
-var recognizers = {
-    pinch: function (tracks, event) {
-        var trackLen = tracks.length;
-        if (!trackLen) {
-            return;
-        }
-        var pinchEnd = (tracks[trackLen - 1] || {}).points;
-        var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd;
-        if (pinchPre
-            && pinchPre.length > 1
-            && pinchEnd
-            && pinchEnd.length > 1) {
-            var pinchScale = dist(pinchEnd) / dist(pinchPre);
-            !isFinite(pinchScale) && (pinchScale = 1);
-            event.pinchScale = pinchScale;
-            var pinchCenter = center(pinchEnd);
-            event.pinchX = pinchCenter[0];
-            event.pinchY = pinchCenter[1];
-            return {
-                type: 'pinch',
-                target: tracks[0].target,
-                event: event
-            };
-        }
-    }
-};
-
-export { GestureMgr };

package/esm/node_modules/zrender/lib/core/LRU.js

@@ -1,110 +0,0 @@
-var Entry = (function () {
-    function Entry(val) {
-        this.value = val;
-    }
-    return Entry;
-}());
-var LinkedList = (function () {
-    function LinkedList() {
-        this._len = 0;
-    }
-    LinkedList.prototype.insert = function (val) {
-        var entry = new Entry(val);
-        this.insertEntry(entry);
-        return entry;
-    };
-    LinkedList.prototype.insertEntry = function (entry) {
-        if (!this.head) {
-            this.head = this.tail = entry;
-        }
-        else {
-            this.tail.next = entry;
-            entry.prev = this.tail;
-            entry.next = null;
-            this.tail = entry;
-        }
-        this._len++;
-    };
-    LinkedList.prototype.remove = function (entry) {
-        var prev = entry.prev;
-        var next = entry.next;
-        if (prev) {
-            prev.next = next;
-        }
-        else {
-            this.head = next;
-        }
-        if (next) {
-            next.prev = prev;
-        }
-        else {
-            this.tail = prev;
-        }
-        entry.next = entry.prev = null;
-        this._len--;
-    };
-    LinkedList.prototype.len = function () {
-        return this._len;
-    };
-    LinkedList.prototype.clear = function () {
-        this.head = this.tail = null;
-        this._len = 0;
-    };
-    return LinkedList;
-}());
-var LRU = (function () {
-    function LRU(maxSize) {
-        this._list = new LinkedList();
-        this._maxSize = 10;
-        this._map = {};
-        this._maxSize = maxSize;
-    }
-    LRU.prototype.put = function (key, value) {
-        var list = this._list;
-        var map = this._map;
-        var removed = null;
-        if (map[key] == null) {
-            var len = list.len();
-            var entry = this._lastRemovedEntry;
-            if (len >= this._maxSize && len > 0) {
-                var leastUsedEntry = list.head;
-                list.remove(leastUsedEntry);
-                delete map[leastUsedEntry.key];
-                removed = leastUsedEntry.value;
-                this._lastRemovedEntry = leastUsedEntry;
-            }
-            if (entry) {
-                entry.value = value;
-            }
-            else {
-                entry = new Entry(value);
-            }
-            entry.key = key;
-            list.insertEntry(entry);
-            map[key] = entry;
-        }
-        return removed;
-    };
-    LRU.prototype.get = function (key) {
-        var entry = this._map[key];
-        var list = this._list;
-        if (entry != null) {
-            if (entry !== list.tail) {
-                list.remove(entry);
-                list.insertEntry(entry);
-            }
-            return entry.value;
-        }
-    };
-    LRU.prototype.clear = function () {
-        this._list.clear();
-        this._map = {};
-    };
-    LRU.prototype.len = function () {
-        return this._list.len();
-    };
-    return LRU;
-}());
-var LRU$1 = LRU;
-
-export { Entry, LinkedList, LRU$1 as default };

package/esm/node_modules/zrender/lib/core/OrientedBoundingRect.js

@@ -1,123 +0,0 @@
-import Point from './Point.js';
-
-var extent = [0, 0];
-var extent2 = [0, 0];
-var minTv = new Point();
-var maxTv = new Point();
-var OrientedBoundingRect = (function () {
-    function OrientedBoundingRect(rect, transform) {
-        this._corners = [];
-        this._axes = [];
-        this._origin = [0, 0];
-        for (var i = 0; i < 4; i++) {
-            this._corners[i] = new Point();
-        }
-        for (var i = 0; i < 2; i++) {
-            this._axes[i] = new Point();
-        }
-        if (rect) {
-            this.fromBoundingRect(rect, transform);
-        }
-    }
-    OrientedBoundingRect.prototype.fromBoundingRect = function (rect, transform) {
-        var corners = this._corners;
-        var axes = this._axes;
-        var x = rect.x;
-        var y = rect.y;
-        var x2 = x + rect.width;
-        var y2 = y + rect.height;
-        corners[0].set(x, y);
-        corners[1].set(x2, y);
-        corners[2].set(x2, y2);
-        corners[3].set(x, y2);
-        if (transform) {
-            for (var i = 0; i < 4; i++) {
-                corners[i].transform(transform);
-            }
-        }
-        Point.sub(axes[0], corners[1], corners[0]);
-        Point.sub(axes[1], corners[3], corners[0]);
-        axes[0].normalize();
-        axes[1].normalize();
-        for (var i = 0; i < 2; i++) {
-            this._origin[i] = axes[i].dot(corners[0]);
-        }
-    };
-    OrientedBoundingRect.prototype.intersect = function (other, mtv) {
-        var overlapped = true;
-        var noMtv = !mtv;
-        minTv.set(Infinity, Infinity);
-        maxTv.set(0, 0);
-        if (!this._intersectCheckOneSide(this, other, minTv, maxTv, noMtv, 1)) {
-            overlapped = false;
-            if (noMtv) {
-                return overlapped;
-            }
-        }
-        if (!this._intersectCheckOneSide(other, this, minTv, maxTv, noMtv, -1)) {
-            overlapped = false;
-            if (noMtv) {
-                return overlapped;
-            }
-        }
-        if (!noMtv) {
-            Point.copy(mtv, overlapped ? minTv : maxTv);
-        }
-        return overlapped;
-    };
-    OrientedBoundingRect.prototype._intersectCheckOneSide = function (self, other, minTv, maxTv, noMtv, inverse) {
-        var overlapped = true;
-        for (var i = 0; i < 2; i++) {
-            var axis = this._axes[i];
-            this._getProjMinMaxOnAxis(i, self._corners, extent);
-            this._getProjMinMaxOnAxis(i, other._corners, extent2);
-            if (extent[1] < extent2[0] || extent[0] > extent2[1]) {
-                overlapped = false;
-                if (noMtv) {
-                    return overlapped;
-                }
-                var dist0 = Math.abs(extent2[0] - extent[1]);
-                var dist1 = Math.abs(extent[0] - extent2[1]);
-                if (Math.min(dist0, dist1) > maxTv.len()) {
-                    if (dist0 < dist1) {
-                        Point.scale(maxTv, axis, -dist0 * inverse);
-                    }
-                    else {
-                        Point.scale(maxTv, axis, dist1 * inverse);
-                    }
-                }
-            }
-            else if (minTv) {
-                var dist0 = Math.abs(extent2[0] - extent[1]);
-                var dist1 = Math.abs(extent[0] - extent2[1]);
-                if (Math.min(dist0, dist1) < minTv.len()) {
-                    if (dist0 < dist1) {
-                        Point.scale(minTv, axis, dist0 * inverse);
-                    }
-                    else {
-                        Point.scale(minTv, axis, -dist1 * inverse);
-                    }
-                }
-            }
-        }
-        return overlapped;
-    };
-    OrientedBoundingRect.prototype._getProjMinMaxOnAxis = function (dim, corners, out) {
-        var axis = this._axes[dim];
-        var origin = this._origin;
-        var proj = corners[0].dot(axis) + origin[dim];
-        var min = proj;
-        var max = proj;
-        for (var i = 1; i < corners.length; i++) {
-            var proj_1 = corners[i].dot(axis) + origin[dim];
-            min = Math.min(proj_1, min);
-            max = Math.max(proj_1, max);
-        }
-        out[0] = min;
-        out[1] = max;
-    };
-    return OrientedBoundingRect;
-}());
-var OrientedBoundingRect$1 = OrientedBoundingRect;
-
-export { OrientedBoundingRect$1 as default };